/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using ForwardWindow11Stride4 = WindowStrideTest<Pair, 11, 4>;
TYPED_TEST_SUITE(ForwardWindow11Stride4, GTestTypeTriples);
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x15x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      236621., 377531.,  403095.,  258769., 510587., 798721., 828245., 522599.,
      801647., 1241581., 1271105., 795179., 372057., 565103., 577115., 353437.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x15x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {798721., 828245., 1241581., 1271105.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x15x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      470841.,  473242.,  751135.,  755062.,  801955.,  806190.,  514745.,
      517538.,  1015091., 1021174., 1587641., 1597442., 1646205., 1656490.,
      1038499., 1045198., 1592591., 1603294., 2466101., 2483162., 2524665.,
      2542210., 1579039., 1590358., 735833.,  744114.,  1117039., 1130206.,
      1140755., 1154230., 698201.,  706874.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x15x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1587641., 1597442., 1646205.,
                                         1656490., 2466101., 2483162.,
                                         2524665., 2542210.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x15x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      939281.,  941682.,  944083.,  946484.,  1498343., 1502270., 1506197.,
      1510124., 1599675., 1603910., 1608145., 1612380., 1026697., 1029490.,
      1032283., 1035076., 2024099., 2030182., 2036265., 2042348., 3165481.,
      3175282., 3185083., 3194884., 3282125., 3292410., 3302695., 3312980.,
      2070299., 2076998., 2083697., 2090396., 3174479., 3185182., 3195885.,
      3206588., 4915141., 4932202., 4949263., 4966324., 5031785., 5049330.,
      5066875., 5084420., 3146759., 3158078., 3169397., 3180716., 1463385.,
      1471666., 1479947., 1488228., 2220911., 2234078., 2247245., 2260412.,
      2268035., 2281510., 2294985., 2308460., 1387729., 1396402., 1405075.,
      1413748.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x15x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3165481., 3175282., 3185083., 3194884., 3282125., 3292410.,
      3302695., 3312980., 4915141., 4932202., 4949263., 4966324.,
      5031785., 5049330., 5066875., 5084420.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x15x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1879885., 2999689., 3203585., 2056677., 4062905.,  6355525.,
      6590749., 4158385., 6382145., 9883885., 10119109., 6329785.,
      2955925., 4488561., 4584041., 2806573.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x15x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6355525., 6590749., 9883885.,
                                         10119109.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x15x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1421895., 1431450., 2228995., 2244626., 2402083., 2418946., 1530711.,
      1541834., 2123699., 2140786., 3136735., 3163018., 3126015., 3152186.,
      1912323., 1928290., 2954899., 2976130., 4188351., 4221146., 4013791.,
      4046474., 2251235., 2271346., 1157367., 1168938., 1772147., 1789410.,
      1859475., 1875922., 1243655., 1253210.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x15x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3136735., 3163018., 3126015.,
                                         3152186., 4188351., 4221146.,
                                         4013791., 4046474.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x15x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1278011., 1287566., 1297121., 1306676., 1993207., 2008838., 2024469.,
      2040100., 2153831., 2170694., 2187557., 2204420., 1423163., 1434286.,
      1445409., 1456532., 2340263., 2357350., 2374437., 2391524., 3696659.,
      3722942., 3749225., 3775508., 3441859., 3468030., 3494201., 3520372.,
      1889447., 1905414., 1921381., 1937348., 2773815., 2795046., 2816277.,
      2837508., 3864163., 3896958., 3929753., 3962548., 3805971., 3838654.,
      3871337., 3904020., 2247735., 2267846., 2287957., 2308068., 1224891.,
      1236462., 1248033., 1259604., 1700215., 1717478., 1734741., 1752004.,
      1744615., 1761062., 1777509., 1793956., 1106875., 1116430., 1125985.,
      1135540.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x15x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3696659., 3722942., 3749225., 3775508., 3441859., 3468030.,
      3494201., 3520372., 3864163., 3896958., 3929753., 3962548.,
      3805971., 3838654., 3871337., 3904020.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x15x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2519646., 3862438., 4129222., 2809086., 4805094., 6778382.,
      6473134., 3978758., 4936134., 7103598., 6778382., 3824614.,
      2875454., 4420102., 4209190., 2531038.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x15x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6778382., 6473134., 7103598.,
                                         6778382.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x15x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3264978., 3285692., 4472234., 4504908., 4267690., 4301196., 2771090.,
      2793980., 4916074., 4952524., 7522402., 7578140., 7027042., 7082332.,
      3933482., 3968524., 4995690., 5034380., 7268194., 7327452., 7522402.,
      7578140., 4199466., 4233676., 2734098., 2758780., 3870442., 3908620.,
      3713002., 3748940., 2190034., 2210748.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x15x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7522402., 7578140., 7027042.,
                                         7082332., 7268194., 7327452.,
                                         7522402., 7578140.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x15x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2782906., 2803620., 2824334., 2845048., 4006322., 4038996., 4071670.,
      4104344., 3973234., 4006740., 4040246., 4073752., 2626490., 2649380.,
      2672270., 2695160., 4228210., 4264660., 4301110., 4337560., 7699722.,
      7755460., 7811198., 7866936., 6824138., 6879428., 6934718., 6990008.,
      3933042., 3968084., 4003126., 4038168., 4286898., 4325588., 4364278.,
      4402968., 7073098., 7132356., 7191614., 7250872., 7699722., 7755460.,
      7811198., 7866936., 3990706., 4024916., 4059126., 4093336., 2842554.,
      2867236., 2891918., 2916600., 4229298., 4267476., 4305654., 4343832.,
      4178802., 4214740., 4250678., 4286616., 2782906., 2803620., 2824334.,
      2845048.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x15x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7699722., 7755460., 7811198., 7866936., 6824138., 6879428.,
      6934718., 6990008., 7073098., 7132356., 7191614., 7250872.,
      7699722., 7755460., 7811198., 7866936.};
  const std::array<int, 4> in_shape = {{1, 15, 15, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x16x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      288148., 406483.,  432047.,  276801., 620092., 856317., 885841., 558327.,
      972092., 1328701., 1358225., 849079., 449092., 604527., 616539., 377349.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x16x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {848936., 878460., 1321320., 1350844.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x16x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      573356.,  576296.,  808731.,  812966.,  859551.,  864094.,  550613.,
      553602.,  1232748., 1240184., 1702107., 1712634., 1760671., 1771682.,
      1109493., 1116654., 1931116., 1944184., 2639131., 2657402., 2697695.,
      2716450., 1686069., 1698158., 888076.,  898184.,  1194963., 1209054.,
      1218679., 1233078., 745437.,  754698.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x16x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1687466., 1697872., 1746030.,
                                         1756920., 2624490., 2642640.,
                                         2683054., 2701688.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x16x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1143772., 1146712., 1149652., 1152592., 1613227., 1617462., 1621697.,
      1625932., 1714559., 1719102., 1723645., 1728188., 1098237., 1101226.,
      1104215., 1107204., 2458060., 2465496., 2472932., 2480368., 3393687.,
      3404214., 3414741., 3425268., 3510331., 3521342., 3532353., 3543364.,
      2211825., 2218986., 2226147., 2233308., 3849164., 3862232., 3875300.,
      3888368., 5259991., 5278262., 5296533., 5314804., 5376635., 5395390.,
      5414145., 5432900., 3360049., 3372138., 3384227., 3396316., 1766044.,
      1776152., 1786260., 1796368., 2375835., 2389926., 2404017., 2418108.,
      2422959., 2437358., 2451757., 2466156., 1481613., 1490874., 1500135.,
      1509396.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x16x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3364526., 3374932., 3385338., 3395744., 3481170., 3492060.,
      3502950., 3513840., 5230830., 5248980., 5267130., 5285280.,
      5347474., 5366108., 5384742., 5403376.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x16x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2289896., 3230689., 3434585., 2200541.,  4934952.,  6814841.,
      7050065., 4443285., 7739688., 10578425., 10813649., 6759445.,
      3568040., 4802105., 4897585., 2996693.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x16x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6756035., 6991259., 10519619.,
                                         10754843.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x16x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1724952., 1736656., 2404067., 2420930., 2577155., 2595250., 1638455.,
      1650362., 2180216., 2197584., 3074543., 3099634., 3309583., 3336610.,
      2157715., 2175530., 2950264., 2973776., 4033519., 4067058., 4268559.,
      4304034., 2641555., 2664746., 1508248., 1519952., 2132371., 2149234.,
      2268851., 2286946., 1514023., 1525930.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x16x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3015783., 3040390., 3250823.,
                                         3277366., 3974759., 4007814.,
                                         4209799., 4244790.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x16x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1556344., 1568048., 1579752., 1591456., 2150631., 2167494., 2184357.,
      2201220., 2311255., 2329350., 2347445., 2365540., 1523179., 1535086.,
      1546993., 1558900., 2320152., 2337520., 2354888., 2372256., 3149531.,
      3174622., 3199713., 3224804., 3384203., 3411230., 3438257., 3465284.,
      2120335., 2138150., 2155965., 2173780., 2936600., 2960112., 2983624.,
      3007136., 3944923., 3978462., 4012001., 4045540., 4179595., 4215070.,
      4250545., 4286020., 2623887., 2647078., 2670269., 2693460., 1465464.,
      1477168., 1488872., 1500576., 1999175., 2016038., 2032901., 2049764.,
      2139831., 2157926., 2176021., 2194116., 1365707., 1377614., 1389521.,
      1401428.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x16x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3090863., 3115470., 3140077., 3164684., 3325535., 3352078.,
      3378621., 3405164., 3886255., 3919310., 3952365., 3985420.,
      4120927., 4155918., 4190909., 4225900.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x16x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2766032., 4137158., 4831974., 3241630., 4588304., 6693118.,
      7637150., 4964022., 4588304., 6693118., 7637150., 4964022.,
      2557904., 3759462., 4307846., 2861502.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x16x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6457110., 7401142., 6457110.,
                                         7401142.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x16x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2980144., 3002272., 4254890., 4288396., 4902314., 4940748., 3174290.,
      3200316., 4739952., 4776480., 6705378., 6760444., 7651810., 7714620.,
      4864426., 4906860., 4739952., 4776480., 6705378., 6760444., 7651810.,
      7714620., 4864426., 4906860., 2618160., 2640288., 3749866., 3783372.,
      4317418., 4355852., 2776018., 2802044.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x16x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6468770., 6521900., 7415202.,
                                         7476076., 6468770., 6521900.,
                                         7415202., 7476076.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x16x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2390000., 2412128., 2434256., 2456384., 3964018., 3997524., 4031030.,
      4064536., 4582194., 4620628., 4659062., 4697496., 3007866., 3033892.,
      3059918., 3085944., 4354608., 4391136., 4427664., 4464192., 6664362.,
      6719428., 6774494., 6829560., 7615594., 7678404., 7741214., 7804024.,
      4837266., 4879700., 4922134., 4964568., 4354608., 4391136., 4427664.,
      4464192., 6664362., 6719428., 6774494., 6829560., 7615594., 7678404.,
      7741214., 7804024., 4837266., 4879700., 4922134., 4964568., 3070960.,
      3093088., 3115216., 3137344., 4242674., 4276180., 4309686., 4343192.,
      4848562., 4886996., 4925430., 4963864., 2991098., 3017124., 3043150.,
      3069176.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x16x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6426554., 6479684., 6532814., 6585944., 7377786., 7438660.,
      7499534., 7560408., 6426554., 6479684., 6532814., 6585944.,
      7377786., 7438660., 7499534., 7560408.};
  const std::array<int, 4> in_shape = {{1, 15, 16, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x18x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      280574., 445214., 470778., 445830., 268366.,  608762.,  949366.,
      978890., 907500., 538208., 958034., 1480798., 1510322., 1386660.,
      816200., 444822., 674366., 686378., 626010.,  360682.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x18x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {949366., 978890., 1480798., 1510322.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x18x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      558306.,  561148.,  885808.,  890428.,  936628.,  941556.,  886935.,
      891660.,  533813.,  536732.,  1210286., 1217524., 1887116., 1898732.,
      1945680., 1957780., 1803615., 1815000., 1069453., 1076416., 1903286.,
      1916068., 2941268., 2961596., 2999832., 3020644., 2754015., 2773320.,
      1620685., 1632400., 879746.,  889644.,  1333024., 1348732., 1356740.,
      1372756., 1237215., 1252020., 712397.,  721364.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x18x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1887116., 1898732., 1945680.,
                                         1957780., 2941268., 2961596.,
                                         2999832., 3020644.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x18x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1113770., 1116612., 1119454., 1122296., 1766996., 1771616., 1776236.,
      1780856., 1868328., 1873256., 1878184., 1883112., 1769145., 1773870.,
      1778595., 1783320., 1064707., 1067626., 1070545., 1073464., 2413334.,
      2420572., 2427810., 2435048., 3762616., 3774232., 3785848., 3797464.,
      3879260., 3891360., 3903460., 3915560., 3595845., 3607230., 3618615.,
      3630000., 2131943., 2138906., 2145869., 2152832., 3793790., 3806572.,
      3819354., 3832136., 5862208., 5882536., 5902864., 5923192., 5978852.,
      5999664., 6020476., 6041288., 5488725., 5508030., 5527335., 5546640.,
      3229655., 3241370., 3253085., 3264800., 1749594., 1759492., 1769390.,
      1779288., 2650340., 2666048., 2681756., 2697464., 2697464., 2713480.,
      2729496., 2745512., 2459625., 2474430., 2489235., 2504040., 1415827.,
      1424794., 1433761., 1442728.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x18x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3762616., 3774232., 3785848., 3797464., 3879260., 3891360.,
      3903460., 3915560., 5862208., 5882536., 5902864., 5923192.,
      5978852., 5999664., 6020476., 6041288.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x18x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2230627., 3539767., 3743663., 3545710., 2134370.,  4845995.,  7557055.,
      7792279., 7224030., 4284082., 7629083., 11791087., 12026311., 11041470.,
      6498514., 3534811., 5357583., 5453063., 4973150.,  2864498.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x18x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7557055., 7792279., 11791087.,
                                         12026311.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x18x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1685391., 1696710., 2624395., 2642798., 2797483., 2817118., 2671182.,
      2690012., 1576786., 1588420., 2122635., 2138198., 3331959., 3356798.,
      3509655., 3535406., 3414854., 3439804., 2050778., 2066276., 2590667.,
      2612534., 3625399., 3658974., 3327959., 3360398., 3190598., 3221628.,
      1852634., 1871780., 1749567., 1762486., 2745339., 2765086., 2849051.,
      2867982., 2763950., 2782140., 1679602., 1690852.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x18x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3331959., 3356798., 3509655.,
                                         3535406., 3625399., 3658974.,
                                         3327959., 3360398.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x18x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1514471., 1525790., 1537109., 1548428., 2345011., 2363414., 2381817.,
      2400220., 2505635., 2525270., 2544905., 2564540., 2422798., 2441628.,
      2460458., 2479288., 1440050., 1451684., 1463318., 1474952., 2017099.,
      2032662., 2048225., 2063788., 2991847., 3016686., 3041525., 3066364.,
      3112855., 3138606., 3164357., 3190108., 3076118., 3101068., 3126018.,
      3150968., 1762090., 1777588., 1793086., 1808584., 2840363., 2862230.,
      2884097., 2905964., 4086087., 4119662., 4153237., 4186812., 4045303.,
      4077742., 4110181., 4142620., 3973206., 4004236., 4035266., 4066296.,
      2296042., 2315188., 2334334., 2353480., 1682951., 1695870., 1708789.,
      1721708., 2476755., 2496502., 2516249., 2535996., 2553923., 2572854.,
      2591785., 2610716., 2526030., 2544220., 2562410., 2580600., 1444850.,
      1456100., 1467350., 1478600.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x18x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2991847., 3016686., 3041525., 3066364., 3112855., 3138606.,
      3164357., 3190108., 4086087., 4119662., 4153237., 4186812.,
      4045303., 4077742., 4110181., 4142620.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x18x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3083590., 4924782., 5273486., 5145332., 3111724., 5326174., 8267046.,
      7738054., 6590404., 3411164., 4898206., 7219814., 6952966., 7013188.,
      4266332., 2963430., 4752782., 4844974., 4586420., 2639980.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x18x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8267046., 7738054., 7219814.,
                                         6952966.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x18x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3234834., 3258508., 4846058., 4884700., 4805354., 4844828., 4439612.,
      4475880., 2552036., 2573912., 4928042., 4966588., 7417122., 7479372.,
      7261730., 7322508., 6888588., 6943112., 3802132., 3833272., 4957226.,
      4995388., 7388962., 7449292., 7495714., 7554572., 7634060., 7690376.,
      4527124., 4560568., 3678802., 3704780., 5630762., 5671708., 5555242.,
      5593948., 4819388., 4855144., 2375012., 2395352.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x18x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7417122., 7479372., 7261730.,
                                         7322508., 7388962., 7449292.,
                                         7495714., 7554572.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x15x18x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2736042., 2759716., 2783390., 2807064., 4596450., 4635092., 4673734.,
      4712376., 4891042., 4930516., 4969990., 5009464., 4645580., 4681848.,
      4718116., 4754384., 2493012., 2514888., 2536764., 2558640., 4929986.,
      4968532., 5007078., 5045624., 7879962., 7942212., 8004462., 8066712.,
      7423194., 7483972., 7544750., 7605528., 7152156., 7206680., 7261204.,
      7315728., 3942020., 3973160., 4004300., 4035440., 4923202., 4961364.,
      4999526., 5037688., 7792794., 7853124., 7913454., 7973784., 7598170.,
      7657028., 7715886., 7774744., 7428892., 7485208., 7541524., 7597840.,
      4472196., 4505640., 4539084., 4572528., 3333930., 3359908., 3385886.,
      3411864., 5219938., 5260884., 5301830., 5342776., 5071138., 5109844.,
      5148550., 5187256., 4516812., 4552568., 4588324., 4624080., 2700628.,
      2720968., 2741308., 2761648.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x15x18x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7879962., 7942212., 8004462., 8066712., 7423194., 7483972.,
      7544750., 7605528., 7792794., 7853124., 7913454., 7973784.,
      7598170., 7657028., 7715886., 7774744.};
  const std::array<int, 4> in_shape = {{1, 15, 18, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x15x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      300272., 476080.,  503360.,  321440., 583352., 909436., 938960., 590744.,
      874412., 1352296., 1381820., 863324., 402192., 610148., 622160., 380632.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x15x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {798721., 828245., 1241581., 1271105.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x15x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      597380.,  600544.,  947012.,  952160.,  1001220., 1006720., 639268.,
      642880.,  1159466., 1166704., 1807256., 1818872., 1865820., 1877920.,
      1173634., 1181488., 1736966., 1748824., 2685716., 2704592., 2744280.,
      2763640., 1714174., 1726648., 795368.,  804384.,  1205974., 1220296.,
      1229690., 1244320., 751856.,  761264.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x15x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1587641., 1597442., 1646205.,
                                         1656490., 2466101., 2483162.,
                                         2524665., 2542210.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x15x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1191596., 1194760., 1197924., 1201088., 1888876., 1894024., 1899172.,
      1904320., 1996940., 2002440., 2007940., 2013440., 1274924., 1278536.,
      1282148., 1285760., 2311694., 2318932., 2326170., 2333408., 3602896.,
      3614512., 3626128., 3637744., 3719540., 3731640., 3743740., 3755840.,
      2339414., 2347268., 2355122., 2362976., 3462074., 3473932., 3485790.,
      3497648., 5352556., 5371432., 5390308., 5409184., 5469200., 5488560.,
      5507920., 5527280., 3415874., 3428348., 3440822., 3453296., 1581720.,
      1590736., 1599752., 1608768., 2397626., 2411948., 2426270., 2440592.,
      2444750., 2459380., 2474010., 2488640., 1494304., 1503712., 1513120.,
      1522528.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x15x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3165481., 3175282., 3185083., 3194884., 3282125., 3292410.,
      3302695., 3312980., 4915141., 4932202., 4949263., 4966324.,
      5031785., 5049330., 5066875., 5084420.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x15x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2387000., 3784792., 4002328., 2555896.,  4642715.,  7237615.,
      7472839., 4701235., 6961955., 10765975., 11001199., 6872635.,
      3195535., 4846611., 4942091., 3022663.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x15x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6355525., 6590749., 9883885.,
                                         10119109.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x15x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1864760., 1877360., 2918808., 2939312., 3119000., 3140912., 1988280.,
      2002672., 2258795., 2276918., 3421143., 3449054., 3500535., 3528334.,
      2219259., 2236262., 2803275., 2825542., 4022199., 4056622., 3937751.,
      3972062., 2271451., 2292598., 1387887., 1398814., 2218411., 2236198.,
      2354891., 2373910., 1565375., 1577870.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x15x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3136735., 3163018., 3126015.,
                                         3152186., 4188351., 4221146.,
                                         4013791., 4046474.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x15x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1688376., 1700976., 1713576., 1726176., 2611992., 2632496., 2653000.,
      2673504., 2781592., 2803504., 2825416., 2847328., 1820728., 1835120.,
      1849512., 1863904., 2434315., 2452438., 2470561., 2488684., 3388327.,
      3416238., 3444149., 3472060., 3313751., 3341550., 3369349., 3397148.,
      1964683., 1981686., 1998689., 2015692., 2818715., 2840982., 2863249.,
      2885516., 4096503., 4130926., 4165349., 4199772., 4218535., 4252846.,
      4287157., 4321468., 2667035., 2688182., 2709329., 2730476., 1379375.,
      1390302., 1401229., 1412156., 2100699., 2118486., 2136273., 2154060.,
      2241355., 2260374., 2279393., 2298412., 1424815., 1437310., 1449805.,
      1462300.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x15x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3696659., 3722942., 3749225., 3775508., 3441859., 3468030.,
      3494201., 3520372., 3864163., 3896958., 3929753., 3962548.,
      3805971., 3838654., 3871337., 3904020.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x15x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3523344., 5608656., 6164432., 4167184., 4909278., 7198374.,
      7253574., 4635134., 4804798., 7173382., 7198374., 4300766.,
      2534678., 4105470., 4130078., 2593462.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x15x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6778382., 6473134., 7103598.,
                                         6778382.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x15x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3381680., 3407392., 4938224., 4979104., 5130736., 5173152., 3427760.,
      3456544., 5468458., 5509052., 7737378., 7799628., 7962914., 8024716.,
      4926698., 4965884., 5081130., 5119868., 7573282., 7634956., 7737378.,
      7799628., 4832234., 4870588., 2661330., 2683436., 4159658., 4196860.,
      4469162., 4508220., 2855058., 2880364.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x15x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7522402., 7578140., 7027042.,
                                         7082332., 7268194., 7327452.,
                                         7522402., 7578140.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x15x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3003120., 3028832., 3054544., 3080256., 5294640., 5335520., 5376400.,
      5417280., 5268528., 5310944., 5353360., 5395776., 3385072., 3413856.,
      3442640., 3471424., 4845506., 4886100., 4926694., 4967288., 7504666.,
      7566916., 7629166., 7691416., 8070874., 8132676., 8194478., 8256280.,
      4813506., 4852692., 4891878., 4931064., 4760834., 4799572., 4838310.,
      4877048., 7324506., 7386180., 7447854., 7509528., 7504666., 7566916.,
      7629166., 7691416., 4936706., 4975060., 5013414., 5051768., 3060042.,
      3082148., 3104254., 3126360., 4677634., 4714836., 4752038., 4789240.,
      4770498., 4809556., 4848614., 4887672., 2941002., 2966308., 2991614.,
      3016920.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x15x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7699722., 7755460., 7811198., 7866936., 6824138., 6879428.,
      6934718., 6990008., 7073098., 7132356., 7191614., 7250872.,
      7699722., 7755460., 7811198., 7866936.};
  const std::array<int, 4> in_shape = {{1, 16, 15, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x16x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {365360.,  511852.,  539132.,  343700.,
                                         708092.,  974413.,  1003937., 631015.,
                                         1060092., 1446797., 1476321., 921767.,
                                         485380.,  652575.,  664587.,  406357.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x16x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {848936., 878460., 1321320., 1350844.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x16x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      726848.,  730720.,  1018160., 1023704., 1072368., 1078264., 683536.,
      687400.,  1407340., 1416184., 1936363., 1948826., 1994927., 2007874.,
      1253637., 1262030., 2105708., 2120184., 2873387., 2893594., 2931951.,
      2952642., 1830213., 1843534., 959756.,  970760.,  1289827., 1305150.,
      1313543., 1329174., 802669.,  812714.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x16x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1687466., 1697872., 1746030.,
                                         1756920., 2624490., 2642640.,
                                         2683054., 2701688.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x16x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1449824., 1453696., 1457568., 1461440., 2030776., 2036320., 2041864.,
      2047408., 2138840., 2144736., 2150632., 2156528., 1363208., 1367072.,
      1370936., 1374800., 2805836., 2814680., 2823524., 2832368., 3860263.,
      3872726., 3885189., 3897652., 3976907., 3989854., 4002801., 4015748.,
      2498881., 2507274., 2515667., 2524060., 4196940., 4211416., 4225892.,
      4240368., 5726567., 5746774., 5766981., 5787188., 5843211., 5863902.,
      5884593., 5905284., 3647105., 3660426., 3673747., 3687068., 1908508.,
      1919512., 1930516., 1941520., 2564331., 2579654., 2594977., 2610300.,
      2611455., 2627086., 2642717., 2658348., 1595293., 1605338., 1615383.,
      1625428.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x16x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3364526., 3374932., 3385338., 3395744., 3481170., 3492060.,
      3502950., 3513840., 5230830., 5248980., 5267130., 5285280.,
      5347474., 5366108., 5384742., 5403376.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x16x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2905088., 4070176., 4287712., 2733472.,  5636136.,  7755737.,
      7990961., 5022325., 8440872., 11519321., 11754545., 7338485.,
      3856552., 5184025., 5279505., 3227189.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x16x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6756035., 6991259., 10519619.,
                                         10754843.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x16x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2263488., 2278912., 3143928., 3166016., 3344120., 3367616., 2127384.,
      2142784., 2561144., 2580048., 3597935., 3625138., 3832975., 3862114.,
      2500883., 2520042., 3003512., 3028560., 4106351., 4142002., 4341391.,
      4378978., 2698003., 2722538., 1917848., 1933136., 2678291., 2700082.,
      2814771., 2837794., 1857191., 1872234.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x16x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3015783., 3040390., 3250823.,
                                         3277366., 3974759., 4007814.,
                                         4209799., 4244790.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x16x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2054208., 2069632., 2085056., 2100480., 2811816., 2833904., 2855992.,
      2878080., 2981416., 3004912., 3028408., 3051904., 1947400., 1962800.,
      1978200., 1993600., 2392344., 2411248., 2430152., 2449056., 3260315.,
      3287518., 3314721., 3341924., 3494987., 3524126., 3553265., 3582404.,
      2231887., 2251046., 2270205., 2289364., 3402008., 3427056., 3452104.,
      3477152., 4596379., 4632030., 4667681., 4703332., 4831051., 4868638.,
      4906225., 4943812., 3079503., 3104038., 3128573., 3153108., 1904248.,
      1919536., 1934824., 1950112., 2561799., 2583590., 2605381., 2627172.,
      2702455., 2725478., 2748501., 2771524., 1704843., 1719886., 1734929.,
      1749972.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x16x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3090863., 3115470., 3140077., 3164684., 3325535., 3352078.,
      3378621., 3405164., 3886255., 3919310., 3952365., 3985420.,
      4120927., 4155918., 4190909., 4225900.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x16x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4265600., 6264496., 7068080., 4725616., 5459728., 7889790.,
      8833822., 5765942., 5459728., 7889790., 8833822., 5765942.,
      2888656., 4212710., 4761094., 3190334.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x16x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6457110., 7401142., 6457110.,
                                         7401142.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x16x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3674752., 3703552., 5252336., 5295456., 5936368., 5985120., 3938480.,
      3971296., 5821296., 5863968., 8238306., 8301820., 9184738., 9255996.,
      6004138., 6051948., 5821296., 5863968., 8238306., 8301820., 9184738.,
      9255996., 6004138., 6051948., 3863344., 3891616., 5434346., 5476300.,
      6001898., 6048780., 3887058., 3918460.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x16x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6468770., 6521900., 7415202.,
                                         7476076., 6468770., 6521900.,
                                         7415202., 7476076.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x16x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3641472., 3670272., 3699072., 3727872., 5359472., 5402592., 5445712.,
      5488832., 6050160., 6098912., 6147664., 6196416., 3874096., 3906912.,
      3939728., 3972544., 5528112., 5570784., 5613456., 5656128., 8083370.,
      8146884., 8210398., 8273912., 9034602., 9105860., 9177118., 9248376.,
      5866130., 5913940., 5961750., 6009560., 5528112., 5570784., 5613456.,
      5656128., 8083370., 8146884., 8210398., 8273912., 9034602., 9105860.,
      9177118., 9248376., 5866130., 5913940., 5961750., 6009560., 3851248.,
      3879520., 3907792., 3936064., 5506034., 5547988., 5589942., 5631896.,
      6111922., 6158804., 6205686., 6252568., 3962618., 3994020., 4025422.,
      4056824.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x16x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6426554., 6479684., 6532814., 6585944., 7377786., 7438660.,
      7499534., 7560408., 6426554., 6479684., 6532814., 6585944.,
      7377786., 7438660., 7499534., 7560408.};
  const std::array<int, 4> in_shape = {{1, 16, 16, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x18x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      356720.,  562936.,  590216., 555060.,  332636.,  696080.,  1082224.,
      1111748., 1027290., 607706., 1045352., 1613656., 1643180., 1506450.,
      885698.,  480984.,  728420., 740432.,  674520.,  388276.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x18x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {949366., 978890., 1480798., 1510322.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x18x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      709688.,  713440.,  1119800., 1125872., 1174008., 1180432., 1104000.,
      1110120., 661504.,  665272.,  1383536., 1392160., 2150654., 2164448.,
      2209218., 2223496., 2041215., 2054580., 1207261., 1215412., 2076536.,
      2090704., 3204806., 3227312., 3263370., 3286360., 2991615., 3012900.,
      1758493., 1771396., 951188.,  961968.,  1439746., 1456840., 1463462.,
      1480864., 1332975., 1349040., 766829.,  776552.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x18x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1887116., 1898732., 1945680.,
                                         1957780., 2941268., 2961596.,
                                         2999832., 3020644.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x18x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1415624., 1419376., 1423128., 1426880., 2233528., 2239600., 2245672.,
      2251744., 2341592., 2348016., 2354440., 2360864., 2201880., 2208000.,
      2214120., 2220240., 1319240., 1323008., 1326776., 1330544., 2758448.,
      2767072., 2775696., 2784320., 4287514., 4301308., 4315102., 4328896.,
      4404158., 4418436., 4432714., 4446992., 4069065., 4082430., 4095795.,
      4109160., 2406371., 2414522., 2422673., 2430824., 4138904., 4153072.,
      4167240., 4181408., 6387106., 6409612., 6432118., 6454624., 6503750.,
      6526740., 6549730., 6572720., 5961945., 5983230., 6004515., 6025800.,
      3504083., 3516986., 3529889., 3542792., 1891596., 1902376., 1913156.,
      1923936., 2862398., 2879492., 2896586., 2913680., 2909522., 2926924.,
      2944326., 2961728., 2649885., 2665950., 2682015., 2698080., 1523935.,
      1533658., 1543381., 1553104.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x18x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3762616., 3774232., 3785848., 3797464., 3879260., 3891360.,
      3903460., 3915560., 5862208., 5882536., 5902864., 5923192.,
      5978852., 5999664., 6020476., 6041288.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x18x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2837408., 4477792., 4695328., 4416000., 2646400.,  5541767.,  8615563.,
      8850787., 8178390., 4837690., 8324855., 12849595., 13084819., 11995830.,
      7052122., 3822343., 5787243., 5882723., 5358710.,  3083738.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x18x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7557055., 7792279., 11791087.,
                                         12026311.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x18x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1655256., 1667648., 2476344., 2495936., 2484024., 2504000., 2421680.,
      2440960., 1442384., 1454336., 2645403., 2662926., 4175623., 4203542.,
      4398375., 4427206., 4232262., 4260012., 2538842., 2556020., 2127323.,
      2147566., 3016007., 3047030., 2853735., 2883622., 2779206., 2807916.,
      1627994., 1645748., 1955535., 1968398., 2692875., 2712534., 2362411.,
      2381254., 2229550., 2247660., 1291762., 1302964.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x18x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3331959., 3356798., 3509655.,
                                         3535406., 3625399., 3658974.,
                                         3327959., 3360398.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x18x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4411720.,  4426672.,  4441624.,  4456576.,  6863848.,  6888048.,
      6912248.,  6936448.,  7262824.,  7288432.,  7314040.,  7339648.,
      6907920.,  6932320.,  6956720.,  6981120.,  4073968.,  4088992.,
      4104016.,  4119040.,  9714883.,  9749302.,  9783721.,  9818140.,
      14917375., 14972430., 15027485., 15082540., 15385519., 15442510.,
      15499501., 15556492., 14350374., 14403724., 14457074., 14510424.,
      8362906.,  8395444.,  8427982.,  8460520.,  11173539., 11219894.,
      11266249., 11312604., 16284511., 16355982., 16427453., 16498924.,
      15544335., 15613646., 15682957., 15752268., 14570598., 14635148.,
      14699698., 14764248., 8475994.,  8515252.,  8554510.,  8593768.,
      9106783.,  9139614.,  9172445.,  9205276.,  12464971., 12514838.,
      12564705., 12614572., 10873019., 10920022., 10967025., 11014028.,
      9944990.,  9988700.,  10032410., 10076120., 5628962.,  5655524.,
      5682086.,  5708648.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x18x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2991847., 3016686., 3041525., 3066364., 3112855., 3138606.,
      3164357., 3190108., 4086087., 4119662., 4153237., 4186812.,
      4045303., 4077742., 4110181., 4142620.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x18x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3490288., 5477424., 5729072., 5857312., 3654368., 5084910., 8060278.,
      7936790., 7132580., 3938300., 5107502., 7778998., 7655510., 6785316.,
      3490940., 3340726., 4636958., 3995966., 3808532., 2169868.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x18x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8267046., 7738054., 7219814.,
                                         6952966.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x18x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3114672., 3140576., 4736752., 4778080., 4847344., 4888160., 4922784.,
      4960832., 3067744., 3090880., 5386922., 5426140., 8567202., 8630508.,
      8174242., 8236076., 7357580., 7413064., 4216852., 4248568., 5268650.,
      5307484., 7973794., 8035180., 8105122., 8165036., 7349388., 7406664.,
      3909652., 3943672., 3483346., 3509100., 4613034., 4653628., 3857578.,
      3895932., 3485116., 3520552., 1680740., 1700888.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x18x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7417122., 7479372., 7261730.,
                                         7322508., 7388962., 7449292.,
                                         7495714., 7554572.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x16x18x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3427376., 3453280., 3479184., 3505088., 5546608., 5587936., 5629264.,
      5670592., 5096560., 5137376., 5178192., 5219008., 4905632., 4943680.,
      4981728., 5019776., 3023456., 3046592., 3069728., 3092864., 5109794.,
      5149012., 5188230., 5227448., 8335866., 8399172., 8462478., 8525784.,
      7666106., 7727940., 7789774., 7851608., 6803036., 6858520., 6914004.,
      6969488., 4279364., 4311080., 4342796., 4374512., 4545954., 4584788.,
      4623622., 4662456., 7380346., 7441732., 7503118., 7564504., 7497018.,
      7556932., 7616846., 7676760., 6883164., 6940440., 6997716., 7054992.,
      4318020., 4352040., 4386060., 4420080., 3008778., 3034532., 3060286.,
      3086040., 4757698., 4798292., 4838886., 4879480., 4559746., 4598100.,
      4636454., 4674808., 4355340., 4390776., 4426212., 4461648., 2041364.,
      2061512., 2081660., 2101808.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x16x18x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7879962., 7942212., 8004462., 8066712., 7423194., 7483972.,
      7544750., 7605528., 7792794., 7853124., 7913454., 7973784.,
      7598170., 7657028., 7715886., 7774744.};
  const std::array<int, 4> in_shape = {{1, 16, 18, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x15x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      236621.,  377531., 403095.,  258769.,  510587., 798721., 828245.,
      522599.,  801647., 1241581., 1271105., 795179., 866355., 1332155.,
      1356575., 842695., 350637.,  526581.,  535425., 324009.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x15x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {798721., 828245., 1241581., 1271105.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x15x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      470841.,  473242.,  751135.,  755062.,  801955.,  806190.,  514745.,
      517538.,  1015091., 1021174., 1587641., 1597442., 1646205., 1656490.,
      1038499., 1045198., 1592591., 1603294., 2466101., 2483162., 2524665.,
      2542210., 1579039., 1590358., 1719305., 1732710., 2643025., 2664310.,
      2691425., 2713150., 1671425., 1685390., 691971.,  701274.,  1038411.,
      1053162., 1055835., 1070850., 638379.,  648018.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x15x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1587641., 1597442., 1646205.,
                                         1656490., 2466101., 2483162.,
                                         2524665., 2542210.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x15x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      939281.,  941682.,  944083.,  946484.,  1498343., 1502270., 1506197.,
      1510124., 1599675., 1603910., 1608145., 1612380., 1026697., 1029490.,
      1032283., 1035076., 2024099., 2030182., 2036265., 2042348., 3165481.,
      3175282., 3185083., 3194884., 3282125., 3292410., 3302695., 3312980.,
      2070299., 2076998., 2083697., 2090396., 3174479., 3185182., 3195885.,
      3206588., 4915141., 4932202., 4949263., 4966324., 5031785., 5049330.,
      5066875., 5084420., 3146759., 3158078., 3169397., 3180716., 3425205.,
      3438610., 3452015., 3465420., 5264765., 5286050., 5307335., 5328620.,
      5361125., 5382850., 5404575., 5426300., 3328885., 3342850., 3356815.,
      3370780., 1374639., 1383942., 1393245., 1402548., 2062071., 2076822.,
      2091573., 2106324., 2096655., 2111670., 2126685., 2141700., 1267119.,
      1276758., 1286397., 1296036.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x15x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3165481., 3175282., 3185083., 3194884., 3282125., 3292410.,
      3302695., 3312980., 4915141., 4932202., 4949263., 4966324.,
      5031785., 5049330., 5066875., 5084420.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x15x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1879885.,  2999689., 3203585., 2056677.,  4062905., 6355525., 6590749.,
      4158385.,  6382145., 9883885., 10119109., 6329785., 6896050., 10602570.,
      10797050., 6706210., 2783550., 4178790.,  4249014., 2570190.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x15x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6355525., 6590749., 9883885.,
                                         10119109.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x15x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1421895., 1431450., 2228995., 2244626., 2402083., 2418946., 1530711.,
      1541834., 2123699., 2140786., 3136735., 3163018., 3126015., 3152186.,
      1912323., 1928290., 2954899., 2976130., 4188351., 4221146., 4013791.,
      4046474., 2251235., 2271346., 1892406., 1910628., 2829934., 2857620.,
      2906862., 2933748., 1873494., 1889860., 1734474., 1747068., 2569874.,
      2589900., 2587410., 2607980., 1596714., 1610140.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x15x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3136735., 3163018., 3126015.,
                                         3152186., 4188351., 4221146.,
                                         4013791., 4046474.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x15x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1278011., 1287566., 1297121., 1306676., 1993207., 2008838., 2024469.,
      2040100., 2153831., 2170694., 2187557., 2204420., 1423163., 1434286.,
      1445409., 1456532., 2340263., 2357350., 2374437., 2391524., 3696659.,
      3722942., 3749225., 3775508., 3441859., 3468030., 3494201., 3520372.,
      1889447., 1905414., 1921381., 1937348., 2773815., 2795046., 2816277.,
      2837508., 3864163., 3896958., 3929753., 3962548., 3805971., 3838654.,
      3871337., 3904020., 2247735., 2267846., 2287957., 2308068., 2175806.,
      2194028., 2212250., 2230472., 3246774., 3274460., 3302146., 3329832.,
      3344086., 3370972., 3397858., 3424744., 2282686., 2299052., 2315418.,
      2331784., 1673570., 1686164., 1698758., 1711352., 2375402., 2395428.,
      2415454., 2435480., 2409930., 2430500., 2451070., 2471640., 1436386.,
      1449812., 1463238., 1476664.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x15x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3696659., 3722942., 3749225., 3775508., 3441859., 3468030.,
      3494201., 3520372., 3864163., 3896958., 3929753., 3962548.,
      3805971., 3838654., 3871337., 3904020.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x15x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2519646., 3862438., 4129222., 2809086., 4805094., 6778382., 6473134.,
      3978758., 4936134., 7103598., 6778382., 3824614., 4163204., 6344436.,
      6237876., 3790660., 2679708., 4105388., 4286188., 2764508.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x15x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6778382., 6473134., 7103598.,
                                         6778382.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x15x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3264978., 3285692., 4472234., 4504908., 4267690., 4301196., 2771090.,
      2793980., 4916074., 4952524., 7522402., 7578140., 7027042., 7082332.,
      3933482., 3968524., 4995690., 5034380., 7268194., 7327452., 7522402.,
      7578140., 4199466., 4233676., 4302044., 4337928., 6522412., 6578664.,
      6605356., 6660456., 4391772., 4425352., 2412228., 2432824., 3507444.,
      3541336., 3606772., 3640792., 2213444., 2235320.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x15x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7522402., 7578140., 7027042.,
                                         7082332., 7268194., 7327452.,
                                         7522402., 7578140.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x15x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2782906., 2803620., 2824334., 2845048., 4006322., 4038996., 4071670.,
      4104344., 3973234., 4006740., 4040246., 4073752., 2626490., 2649380.,
      2672270., 2695160., 4228210., 4264660., 4301110., 4337560., 7699722.,
      7755460., 7811198., 7866936., 6824138., 6879428., 6934718., 6990008.,
      3933042., 3968084., 4003126., 4038168., 4286898., 4325588., 4364278.,
      4402968., 7073098., 7132356., 7191614., 7250872., 7699722., 7755460.,
      7811198., 7866936., 3990706., 4024916., 4059126., 4093336., 4095884.,
      4131768., 4167652., 4203536., 6492316., 6548568., 6604820., 6661072.,
      6659356., 6714456., 6769556., 6824656., 4708236., 4741816., 4775396.,
      4808976., 2333972., 2354568., 2375164., 2395760., 3769732., 3803624.,
      3837516., 3871408., 3706116., 3740136., 3774156., 3808176., 2353428.,
      2375304., 2397180., 2419056.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x15x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7699722., 7755460., 7811198., 7866936., 6824138., 6879428.,
      6934718., 6990008., 7073098., 7132356., 7191614., 7250872.,
      7699722., 7755460., 7811198., 7866936.};
  const std::array<int, 4> in_shape = {{1, 18, 15, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x16x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      288148.,  406483., 432047.,  276801.,  620092., 856317.,  885841.,
      558327.,  972092., 1328701., 1358225., 849079., 1049100., 1424555.,
      1448975., 899605., 422212.,  562969.,  571813., 345863.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x16x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {848936., 878460., 1321320., 1350844.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x16x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      573356.,  576296.,  808731.,  812966.,  859551.,  864094.,  550613.,
      553602.,  1232748., 1240184., 1702107., 1712634., 1760671., 1771682.,
      1109493., 1116654., 1931116., 1944184., 2639131., 2657402., 2697695.,
      2716450., 1686069., 1698158., 2081840., 2098200., 2826340., 2849110.,
      2874740., 2897950., 1784300., 1799210., 833072.,  844424.,  1110164.,
      1125938., 1127588., 1143626., 681436.,  691726.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x16x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1687466., 1697872., 1746030.,
                                         1756920., 2624490., 2642640.,
                                         2683054., 2701688.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x16x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1143772., 1146712., 1149652., 1152592., 1613227., 1617462., 1621697.,
      1625932., 1714559., 1719102., 1723645., 1728188., 1098237., 1101226.,
      1104215., 1107204., 2458060., 2465496., 2472932., 2480368., 3393687.,
      3404214., 3414741., 3425268., 3510331., 3521342., 3532353., 3543364.,
      2211825., 2218986., 2226147., 2233308., 3849164., 3862232., 3875300.,
      3888368., 5259991., 5278262., 5296533., 5314804., 5376635., 5395390.,
      5414145., 5432900., 3360049., 3372138., 3384227., 3396316., 4147320.,
      4163680., 4180040., 4196400., 5629910., 5652680., 5675450., 5698220.,
      5726270., 5749480., 5772690., 5795900., 3553690., 3568600., 3583510.,
      3598420., 1654792., 1666144., 1677496., 1688848., 2204554., 2220328.,
      2236102., 2251876., 2239138., 2255176., 2271214., 2287252., 1352582.,
      1362872., 1373162., 1383452.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x16x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3364526., 3374932., 3385338., 3395744., 3481170., 3492060.,
      3502950., 3513840., 5230830., 5248980., 5267130., 5285280.,
      5347474., 5366108., 5384742., 5403376.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x16x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2289896.,  3230689., 3434585.,  2200541.,  4934952., 6814841., 7050065.,
      4443285.,  7739688., 10578425., 10813649., 6759445., 8351040., 11338800.,
      11533280., 7159600., 3351680.,  4467848.,  4538072., 2743720.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x16x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6756035., 6991259., 10519619.,
                                         10754843.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x16x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1724952., 1736656., 2404067., 2420930., 2577155., 2595250., 1638455.,
      1650362., 2180216., 2197584., 3074543., 3099634., 3309583., 3336610.,
      2157715., 2175530., 2950264., 2973776., 4033519., 4067058., 4268559.,
      4304034., 2641555., 2664746., 1933616., 1949824., 2721542., 2744928.,
      2920326., 2945472., 1909166., 1925728., 1367504., 1380096., 1878234.,
      1896208., 2009434., 2028464., 1260210., 1272656.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x16x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3015783., 3040390., 3250823.,
                                         3277366., 3974759., 4007814.,
                                         4209799., 4244790.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x16x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1556344., 1568048., 1579752., 1591456., 2150631., 2167494., 2184357.,
      2201220., 2311255., 2329350., 2347445., 2365540., 1523179., 1535086.,
      1546993., 1558900., 2320152., 2337520., 2354888., 2372256., 3149531.,
      3174622., 3199713., 3224804., 3384203., 3411230., 3438257., 3465284.,
      2120335., 2138150., 2155965., 2173780., 2936600., 2960112., 2983624.,
      3007136., 3944923., 3978462., 4012001., 4045540., 4179595., 4215070.,
      4250545., 4286020., 2623887., 2647078., 2670269., 2693460., 2125072.,
      2141280., 2157488., 2173696., 2881714., 2905100., 2928486., 2951872.,
      3089106., 3114252., 3139398., 3164544., 1945258., 1961820., 1978382.,
      1994944., 1510768., 1523360., 1535952., 1548544., 2014078., 2032052.,
      2050026., 2068000., 2144350., 2163380., 2182410., 2201440., 1316294.,
      1328740., 1341186., 1353632.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x16x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3090863., 3115470., 3140077., 3164684., 3325535., 3352078.,
      3378621., 3405164., 3886255., 3919310., 3952365., 3985420.,
      4120927., 4155918., 4190909., 4225900.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x16x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2766032., 4137158., 4831974., 3241630., 4588304., 6693118., 7637150.,
      4964022., 4588304., 6693118., 7637150., 4964022., 3602976., 5282236.,
      6080892., 3970092., 2386400., 3545028., 4071940., 2747220.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x16x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6457110., 7401142., 6457110.,
                                         7401142.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x16x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2980144., 3002272., 4254890., 4288396., 4902314., 4940748., 3174290.,
      3200316., 4739952., 4776480., 6705378., 6760444., 7651810., 7714620.,
      4864426., 4906860., 4739952., 4776480., 6705378., 6760444., 7651810.,
      7714620., 4864426., 4906860., 3957664., 3989568., 5630700., 5678968.,
      6467308., 6522616., 4161052., 4198488., 2279776., 2297280., 3327796.,
      3354504., 3853108., 3884040., 2552452., 2573480.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x16x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6468770., 6521900., 7415202.,
                                         7476076., 6468770., 6521900.,
                                         7415202., 7476076.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x16x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2390000., 2412128., 2434256., 2456384., 3964018., 3997524., 4031030.,
      4064536., 4582194., 4620628., 4659062., 4697496., 3007866., 3033892.,
      3059918., 3085944., 4354608., 4391136., 4427664., 4464192., 6664362.,
      6719428., 6774494., 6829560., 7615594., 7678404., 7741214., 7804024.,
      4837266., 4879700., 4922134., 4964568., 4354608., 4391136., 4427664.,
      4464192., 6664362., 6719428., 6774494., 6829560., 7615594., 7678404.,
      7741214., 7804024., 4837266., 4879700., 4922134., 4964568., 3978400.,
      4010304., 4042208., 4074112., 5982540., 6030808., 6079076., 6127344.,
      6862284., 6917592., 6972900., 7028208., 4369916., 4407352., 4444788.,
      4482224., 2398816., 2416320., 2433824., 2451328., 3405332., 3432040.,
      3458748., 3485456., 3927444., 3958376., 3989308., 4020240., 2548964.,
      2569992., 2591020., 2612048.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x16x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6426554., 6479684., 6532814., 6585944., 7377786., 7438660.,
      7499534., 7560408., 6426554., 6479684., 6532814., 6585944.,
      7377786., 7438660., 7499534., 7560408.};
  const std::array<int, 4> in_shape = {{1, 18, 16, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x18x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      280574., 445214.,  470778.,  445830.,  268366.,  608762.,  949366.,
      978890., 907500.,  538208.,  958034.,  1480798., 1510322., 1386660.,
      816200., 1036350., 1591040., 1615460., 1475925., 862975.,  419538.,
      629112., 637956.,  578655.,  329469.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x18x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {949366., 978890., 1480798., 1510322.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x18x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      558306.,  561148.,  885808.,  890428.,  936628.,  941556.,  886935.,
      891660.,  533813.,  536732.,  1210286., 1217524., 1887116., 1898732.,
      1945680., 1957780., 1803615., 1815000., 1069453., 1076416., 1903286.,
      1916068., 2941268., 2961596., 2999832., 3020644., 2754015., 2773320.,
      1620685., 1632400., 2056670., 2072700., 3156670., 3182080., 3205070.,
      3230920., 2928000., 2951850., 1711520., 1725950., 827946.,  839076.,
      1240602., 1258224., 1258026., 1275912., 1140840., 1157310., 648984.,
      658938.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x18x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1887116., 1898732., 1945680.,
                                         1957780., 2941268., 2961596.,
                                         2999832., 3020644.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x18x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1113770., 1116612., 1119454., 1122296., 1766996., 1771616., 1776236.,
      1780856., 1868328., 1873256., 1878184., 1883112., 1769145., 1773870.,
      1778595., 1783320., 1064707., 1067626., 1070545., 1073464., 2413334.,
      2420572., 2427810., 2435048., 3762616., 3774232., 3785848., 3797464.,
      3879260., 3891360., 3903460., 3915560., 3595845., 3607230., 3618615.,
      3630000., 2131943., 2138906., 2145869., 2152832., 3793790., 3806572.,
      3819354., 3832136., 5862208., 5882536., 5902864., 5923192., 5978852.,
      5999664., 6020476., 6041288., 5488725., 5508030., 5527335., 5546640.,
      3229655., 3241370., 3253085., 3264800., 4097310., 4113340., 4129370.,
      4145400., 6287930., 6313340., 6338750., 6364160., 6384290., 6410140.,
      6435990., 6461840., 5832150., 5856000., 5879850., 5903700., 3408610.,
      3423040., 3437470., 3451900., 1644762., 1655892., 1667022., 1678152.,
      2463582., 2481204., 2498826., 2516448., 2498166., 2516052., 2533938.,
      2551824., 2265210., 2281680., 2298150., 2314620., 1288014., 1297968.,
      1307922., 1317876.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x18x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3762616., 3774232., 3785848., 3797464., 3879260., 3891360.,
      3903460., 3915560., 5862208., 5882536., 5902864., 5923192.,
      5978852., 5999664., 6020476., 6041288.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x18x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2230627., 3539767., 3743663.,  3545710.,  2134370.,  4845995.,  7557055.,
      7792279., 7224030., 4284082.,  7629083.,  11791087., 12026311., 11041470.,
      6498514., 8250760., 12665400., 12859880., 11748800., 6868640.,  3331104.,
      4993296., 5063520., 4592400.,  2613648.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x18x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7557055., 7792279., 11791087.,
                                         12026311.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x18x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1685391., 1696710., 2624395., 2642798., 2797483., 2817118., 2671182.,
      2690012., 1576786., 1588420., 2122635., 2138198., 3331959., 3356798.,
      3509655., 3535406., 3414854., 3439804., 2050778., 2066276., 2590667.,
      2612534., 3625399., 3658974., 3327959., 3360398., 3190598., 3221628.,
      1852634., 1871780., 2173662., 2189584., 3408342., 3433072., 3574358.,
      3598800., 3461180., 3484800., 2085892., 2100544., 1083522., 1094208.,
      1563914., 1580064., 1498506., 1513664., 1492484., 1507104., 899004.,
      908064.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x18x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3331959., 3356798., 3509655.,
                                         3535406., 3625399., 3658974.,
                                         3327959., 3360398.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x18x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1514471., 1525790., 1537109., 1548428., 2345011., 2363414., 2381817.,
      2400220., 2505635., 2525270., 2544905., 2564540., 2422798., 2441628.,
      2460458., 2479288., 1440050., 1451684., 1463318., 1474952., 2017099.,
      2032662., 2048225., 2063788., 2991847., 3016686., 3041525., 3066364.,
      3112855., 3138606., 3164357., 3190108., 3076118., 3101068., 3126018.,
      3150968., 1762090., 1777588., 1793086., 1808584., 2840363., 2862230.,
      2884097., 2905964., 4086087., 4119662., 4153237., 4186812., 4045303.,
      4077742., 4110181., 4142620., 3973206., 4004236., 4035266., 4066296.,
      2296042., 2315188., 2334334., 2353480., 2026890., 2042812., 2058734.,
      2074656., 3041554., 3066284., 3091014., 3115744., 3185458., 3209900.,
      3234342., 3258784., 3166516., 3190136., 3213756., 3237376., 1853132.,
      1867784., 1882436., 1897088., 1499974., 1510660., 1521346., 1532032.,
      1952510., 1968660., 1984810., 2000960., 1691614., 1706772., 1721930.,
      1737088., 1649644., 1664264., 1678884., 1693504., 918036.,  927096.,
      936156.,  945216.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x18x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2991847., 3016686., 3041525., 3066364., 3112855., 3138606.,
      3164357., 3190108., 4086087., 4119662., 4153237., 4186812.,
      4045303., 4077742., 4110181., 4142620.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x18x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3083590., 4924782., 5273486., 5145332., 3111724., 5326174., 8267046.,
      7738054., 6590404., 3411164., 4898206., 7219814., 6952966., 7013188.,
      4266332., 4660524., 7406972., 7562556., 6672680., 3627032., 3131284.,
      4873796., 4998788., 4341592., 2212712.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x18x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8267046., 7738054., 7219814.,
                                         6952966.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x18x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3234834., 3258508., 4846058., 4884700., 4805354., 4844828., 4439612.,
      4475880., 2552036., 2573912., 4928042., 4966588., 7417122., 7479372.,
      7261730., 7322508., 6888588., 6943112., 3802132., 3833272., 4957226.,
      4995388., 7388962., 7449292., 7495714., 7554572., 7634060., 7690376.,
      4527124., 4560568., 5061148., 5099096., 7901548., 7962360., 7984492.,
      8044152., 7034888., 7088208., 3787704., 3817520., 3623044., 3647272.,
      5089460., 5127304., 4816052., 4853000., 4167864., 4201648., 1979784.,
      1999568.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x18x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7417122., 7479372., 7261730.,
                                         7322508., 7388962., 7449292.,
                                         7495714., 7554572.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME1x18x18x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2736042., 2759716., 2783390., 2807064., 4596450., 4635092., 4673734.,
      4712376., 4891042., 4930516., 4969990., 5009464., 4645580., 4681848.,
      4718116., 4754384., 2493012., 2514888., 2536764., 2558640., 4929986.,
      4968532., 5007078., 5045624., 7879962., 7942212., 8004462., 8066712.,
      7423194., 7483972., 7544750., 7605528., 7152156., 7206680., 7261204.,
      7315728., 3942020., 3973160., 4004300., 4035440., 4923202., 4961364.,
      4999526., 5037688., 7792794., 7853124., 7913454., 7973784., 7598170.,
      7657028., 7715886., 7774744., 7428892., 7485208., 7541524., 7597840.,
      4472196., 4505640., 4539084., 4572528., 5022204., 5060152., 5098100.,
      5136048., 7865676., 7926488., 7987300., 8048112., 7770572., 7830232.,
      7889892., 7949552., 6663624., 6716944., 6770264., 6823584., 3982072.,
      4011888., 4041704., 4071520., 2962020., 2986248., 3010476., 3034704.,
      4664724., 4702568., 4740412., 4778256., 4643092., 4680040., 4716988.,
      4753936., 4067704., 4101488., 4135272., 4169056., 2467784., 2487568.,
      2507352., 2527136.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID1x18x18x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7879962., 7942212., 8004462., 8066712., 7423194., 7483972.,
      7544750., 7605528., 7792794., 7853124., 7913454., 7973784.,
      7598170., 7657028., 7715886., 7774744.};
  const std::array<int, 4> in_shape = {{1, 18, 18, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x15x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      236621.,  377531.,  403095.,  258769.,  510587.,  798721.,  828245.,
      522599.,  801647.,  1241581., 1271105., 795179.,  372057.,  565103.,
      577115.,  353437.,  1173746., 1815506., 1841070., 1151794., 1602062.,
      2459446., 2488970., 1544774., 1893122., 2902306., 2931830., 1817354.,
      824082.,  1240778., 1252790., 761362.,  2110871., 3253481., 3279045.,
      2044819., 2693537., 4120171., 4149695., 2566949., 2984597., 4563031.,
      4592555., 2839529., 1276107., 1916453., 1928465., 1169287.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x15x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      798721.,  828245.,  1241581., 1271105., 2459446., 2488970.,
      2902306., 2931830., 4120171., 4149695., 4563031., 4592555.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x15x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      470841.,  473242.,  751135.,  755062.,  801955.,  806190.,  514745.,
      517538.,  1015091., 1021174., 1587641., 1597442., 1646205., 1656490.,
      1038499., 1045198., 1592591., 1603294., 2466101., 2483162., 2524665.,
      2542210., 1579039., 1590358., 735833.,  744114.,  1117039., 1130206.,
      1140755., 1154230., 698201.,  706874.,  2334066., 2347492., 3609760.,
      3631012., 3660580., 3682140., 2289770., 2303588., 3180716., 3204124.,
      4881866., 4918892., 4940430., 4977940., 3065524., 3089548., 3758216.,
      3786244., 5760326., 5804612., 5818890., 5863660., 3606064., 3634708.,
      1628858., 1648164., 2451064., 2481556., 2474780., 2505580., 1503026.,
      1522724., 4197291., 4221742., 6468385., 6506962., 6519205., 6558090.,
      4064795., 4089638., 5346341., 5387074., 8176091., 8240342., 8234655.,
      8299390., 5092549., 5133898., 5923841., 5969194., 9054551., 9126062.,
      9113115., 9185110., 5633089., 5679058., 2521883., 2552214., 3785089.,
      3832906., 3808805., 3856930., 2307851., 2338574.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x15x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1587641., 1597442., 1646205., 1656490., 2466101., 2483162.,
      2524665., 2542210., 4881866., 4918892., 4940430., 4977940.,
      5760326., 5804612., 5818890., 5863660., 8176091., 8240342.,
      8234655., 8299390., 9054551., 9126062., 9113115., 9185110.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x15x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      939281.,   941682.,   944083.,   946484.,   1498343.,  1502270.,
      1506197.,  1510124.,  1599675.,  1603910.,  1608145.,  1612380.,
      1026697.,  1029490.,  1032283.,  1035076.,  2024099.,  2030182.,
      2036265.,  2042348.,  3165481.,  3175282.,  3185083.,  3194884.,
      3282125.,  3292410.,  3302695.,  3312980.,  2070299.,  2076998.,
      2083697.,  2090396.,  3174479.,  3185182.,  3195885.,  3206588.,
      4915141.,  4932202.,  4949263.,  4966324.,  5031785.,  5049330.,
      5066875.,  5084420.,  3146759.,  3158078.,  3169397.,  3180716.,
      1463385.,  1471666.,  1479947.,  1488228.,  2220911.,  2234078.,
      2247245.,  2260412.,  2268035.,  2281510.,  2294985.,  2308460.,
      1387729.,  1396402.,  1405075.,  1413748.,  4654706.,  4668132.,
      4681558.,  4694984.,  7198268.,  7219520.,  7240772.,  7262024.,
      7299600.,  7321160.,  7342720.,  7364280.,  4565722.,  4579540.,
      4593358.,  4607176.,  6338024.,  6361432.,  6384840.,  6408248.,
      9726706.,  9763732.,  9800758.,  9837784.,  9843350.,  9880860.,
      9918370.,  9955880.,  6107024.,  6131048.,  6155072.,  6179096.,
      7488404.,  7516432.,  7544460.,  7572488.,  11476366., 11520652.,
      11564938., 11609224., 11593010., 11637780., 11682550., 11727320.,
      7183484.,  7212128.,  7240772.,  7269416.,  3238410.,  3257716.,
      3277022.,  3296328.,  4871636.,  4902128.,  4932620.,  4963112.,
      4918760.,  4949560.,  4980360.,  5011160.,  2986354.,  3006052.,
      3025750.,  3045448.,  4180435.,  4195158.,  4209881.,  4224604.,
      6216081.,  6238786.,  6261491.,  6284196.,  5953893.,  5975882.,
      5997871.,  6019860.,  3707179.,  3721270.,  3735361.,  3749452.,
      2396973.,  2413642.,  2430311.,  2446980.,  3500731.,  3526582.,
      3552433.,  3578284.,  3434079.,  3459390.,  3484701.,  3510012.,
      2090501.,  2106762.,  2123023.,  2139284.,  2005209.,  2012162.,
      2019115.,  2026068.,  3110231.,  3120814.,  3131397.,  3141980.,
      3223803.,  3233846.,  3243889.,  3253932.,  2034417.,  2040962.,
      2047507.,  2054052.,  974267.,   979510.,   984753.,   989996.,
      1490489.,  1498882.,  1507275.,  1515668.,  1537613.,  1546314.,
      1555015.,  1563716.,  947219.,   952854.,   958489.,   964124.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x15x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3165481.,  3175282.,  3185083.,  3194884.,  3282125.,  3292410.,
      3302695.,  3312980.,  4915141.,  4932202.,  4949263.,  4966324.,
      5031785.,  5049330.,  5066875.,  5084420.,  9726706.,  9763732.,
      9800758.,  9837784.,  9843350.,  9880860.,  9918370.,  9955880.,
      11476366., 11520652., 11564938., 11609224., 11593010., 11637780.,
      11682550., 11727320., 3500731.,  3526582.,  3552433.,  3578284.,
      3434079.,  3459390.,  3484701.,  3510012.,  3110231.,  3120814.,
      3131397.,  3141980.,  3223803.,  3233846.,  3243889.,  3253932.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x15x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1879885., 2999689., 3203585., 2056677.,  4062905., 6355525., 6590749.,
      4158385., 6382145., 9883885., 10119109., 6329785., 2955925., 4488561.,
      4584041., 2806573., 2636371., 4045543.,  4112735., 2602187., 3299319.,
      5086011., 5274643., 3301711., 5183871.,  8060899., 8296123., 5207895.,
      2460731., 3748591., 3844071., 2359987.,  4115801., 6174789., 6013117.,
      3778481., 3258677., 4899889., 4949769.,  3075821., 4007101., 6243033.,
      6473137., 4086005., 1965537., 3008621.,  3104101., 1913401.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x15x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6355525., 6590749., 9883885., 10119109., 5086011., 5274643.,
      8060899., 8296123., 4899889., 4949769.,  6243033., 6473137.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x15x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1421895., 1431450., 2228995., 2244626., 2402083., 2418946., 1530711.,
      1541834., 2123699., 2140786., 3136735., 3163018., 3126015., 3152186.,
      1912323., 1928290., 2954899., 2976130., 4188351., 4221146., 4013791.,
      4046474., 2251235., 2271346., 1157367., 1168938., 1772147., 1789410.,
      1859475., 1875922., 1243655., 1253210., 1928207., 1939366., 3108619.,
      3126478., 3276587., 3295166., 2204895., 2217110., 2714491., 2736878.,
      3905895., 3940726., 3660679., 3694886., 2088587., 2109854., 2512475.,
      2531326., 3916103., 3945670., 4077415., 4106870., 2652779., 2671022.,
      1146879., 1159542., 1632955., 1652446., 1531867., 1550542., 882895.,
      894054.,  1584599., 1597362., 2450195., 2470282., 2520883., 2541178.,
      1674855., 1688162., 2651971., 2672490., 3938799., 3971426., 3989519.,
      4023058., 2468627., 2490586., 2065955., 2083450., 3158479., 3185842.,
      3127279., 3153506., 1942259., 1958634., 1767175., 1780930., 2577155.,
      2598874., 2287651., 2308554., 1245079., 1257842.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x15x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3136735., 3163018., 3126015., 3152186., 4188351., 4221146.,
      4013791., 4046474., 3905895., 3940726., 3660679., 3694886.,
      3916103., 3945670., 4077415., 4106870., 3938799., 3971426.,
      3989519., 4023058., 3158479., 3185842., 3127279., 3153506.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x15x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1278011., 1287566., 1297121., 1306676., 1993207., 2008838., 2024469.,
      2040100., 2153831., 2170694., 2187557., 2204420., 1423163., 1434286.,
      1445409., 1456532., 2340263., 2357350., 2374437., 2391524., 3696659.,
      3722942., 3749225., 3775508., 3441859., 3468030., 3494201., 3520372.,
      1889447., 1905414., 1921381., 1937348., 2773815., 2795046., 2816277.,
      2837508., 3864163., 3896958., 3929753., 3962548., 3805971., 3838654.,
      3871337., 3904020., 2247735., 2267846., 2287957., 2308068., 1224891.,
      1236462., 1248033., 1259604., 1700215., 1717478., 1734741., 1752004.,
      1744615., 1761062., 1777509., 1793956., 1106875., 1116430., 1125985.,
      1135540., 1636743., 1647902., 1659061., 1670220., 2557267., 2575126.,
      2592985., 2610844., 2708163., 2726742., 2745321., 2763900., 1824263.,
      1836478., 1848693., 1860908., 2856067., 2878454., 2900841., 2923228.,
      4021183., 4056014., 4090845., 4125676., 3822191., 3856398., 3890605.,
      3924812., 2299139., 2320406., 2341673., 2362940., 2410515., 2429366.,
      2448217., 2467068., 3559439., 3589006., 3618573., 3648140., 3648703.,
      3678158., 3707613., 3737068., 2328723., 2346966., 2365209., 2383452.,
      1706631., 1719294., 1731957., 1744620., 2435411., 2454902., 2474393.,
      2493884., 2102979., 2121654., 2140329., 2159004., 1050375., 1061534.,
      1072693., 1083852., 1868499., 1881262., 1894025., 1906788., 2666671.,
      2686758., 2706845., 2726932., 2623519., 2643814., 2664109., 2684404.,
      1651923., 1665230., 1678537., 1691844., 2596703., 2617222., 2637741.,
      2658260., 3801451., 3834078., 3866705., 3899332., 3930651., 3964190.,
      3997729., 4031268., 2465631., 2487590., 2509549., 2531508., 2300143.,
      2317638., 2335133., 2352628., 3593659., 3621022., 3648385., 3675748.,
      3561067., 3587294., 3613521., 3639748., 2020591., 2036966., 2053341.,
      2069716., 1746003., 1759758., 1773513., 1787268., 2453807., 2475526.,
      2497245., 2518964., 2268831., 2289734., 2310637., 2331540., 1260115.,
      1272878., 1285641., 1298404.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x15x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3696659., 3722942., 3749225., 3775508., 3441859., 3468030., 3494201.,
      3520372., 3864163., 3896958., 3929753., 3962548., 3805971., 3838654.,
      3871337., 3904020., 4021183., 4056014., 4090845., 4125676., 3822191.,
      3856398., 3890605., 3924812., 3559439., 3589006., 3618573., 3648140.,
      3648703., 3678158., 3707613., 3737068., 3801451., 3834078., 3866705.,
      3899332., 3930651., 3964190., 3997729., 4031268., 3593659., 3621022.,
      3648385., 3675748., 3561067., 3587294., 3613521., 3639748.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x15x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2519646., 3862438., 4129222., 2809086., 4805094., 6778382., 6473134.,
      3978758., 4936134., 7103598., 6778382., 3824614., 2875454., 4420102.,
      4209190., 2531038., 4482566., 6664494., 6543694., 4361126., 5664366.,
      8449270., 8346262., 5127054., 5612622., 8526166., 8449270., 5360494.,
      2999526., 4569742., 4541614., 2860678., 2492334., 3987638., 4476630.,
      3028046., 4558582., 6609374., 6722942., 4269846., 4968150., 6989374.,
      6609374., 3893494., 3013006., 4412182., 4038966., 2317358.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x15x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6778382., 6473134., 7103598., 6778382., 8449270., 8346262.,
      8526166., 8449270., 6609374., 6722942., 6989374., 6609374.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x15x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3264978., 3285692., 4472234., 4504908., 4267690., 4301196., 2771090.,
      2793980., 4916074., 4952524., 7522402., 7578140., 7027042., 7082332.,
      3933482., 3968524., 4995690., 5034380., 7268194., 7327452., 7522402.,
      7578140., 4199466., 4233676., 2734098., 2758780., 3870442., 3908620.,
      3713002., 3748940., 2190034., 2210748., 3788818., 3815948., 5557738.,
      5599324., 5627626., 5669020., 3921106., 3948364., 5558698., 5602012.,
      7867554., 7933932., 7777698., 7842604., 4901226., 4942108., 6060202.,
      6104732., 8428450., 8497324., 7867554., 7933932., 4892778., 4933852.,
      3944530., 3973580., 5865770., 5911836., 5286442., 5331292., 2887954.,
      2915084., 2973266., 2993500., 4353578., 4386668., 4591402., 4627372.,
      2978066., 3002524., 4906986., 4942828., 7241954., 7297468., 7057890.,
      7115004., 4226474., 4263980., 5019370., 5057452., 7360482., 7418492.,
      7241954., 7297468., 4050090., 4084716., 2844818., 2870044., 3855210.,
      3892780., 3636330., 3670636., 2115410., 2135644.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x15x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7522402., 7578140., 7027042., 7082332., 7268194., 7327452.,
      7522402., 7578140., 7867554., 7933932., 7777698., 7842604.,
      8428450., 8497324., 7867554., 7933932., 7241954., 7297468.,
      7057890., 7115004., 7360482., 7418492., 7241954., 7297468.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x15x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2782906., 2803620., 2824334., 2845048., 4006322., 4038996., 4071670.,
      4104344., 3973234., 4006740., 4040246., 4073752., 2626490., 2649380.,
      2672270., 2695160., 4228210., 4264660., 4301110., 4337560., 7699722.,
      7755460., 7811198., 7866936., 6824138., 6879428., 6934718., 6990008.,
      3933042., 3968084., 4003126., 4038168., 4286898., 4325588., 4364278.,
      4402968., 7073098., 7132356., 7191614., 7250872., 7699722., 7755460.,
      7811198., 7866936., 3990706., 4024916., 4059126., 4093336., 2842554.,
      2867236., 2891918., 2916600., 4229298., 4267476., 4305654., 4343832.,
      4178802., 4214740., 4250678., 4286616., 2782906., 2803620., 2824334.,
      2845048., 3177002., 3204132., 3231262., 3258392., 5345122., 5386708.,
      5428294., 5469880., 5599778., 5641172., 5682566., 5723960., 3767082.,
      3794340., 3821598., 3848856., 5072418., 5115732., 5159046., 5202360.,
      7752698., 7819076., 7885454., 7951832., 7951290., 8016196., 8081102.,
      8146008., 5326114., 5366996., 5407878., 5448760., 5713762., 5758292.,
      5802822., 5847352., 8233018., 8301892., 8370766., 8439640., 7752698.,
      7819076., 7885454., 7951832., 5096034., 5137108., 5178182., 5219256.,
      3850026., 3879076., 3908126., 3937176., 5983842., 6029908., 6075974.,
      6122040., 5350690., 5395540., 5440390., 5485240., 3177002., 3204132.,
      3231262., 3258392., 2478490., 2498724., 2518958., 2539192., 3957010.,
      3990100., 4023190., 4056280., 4282322., 4318292., 4354262., 4390232.,
      2825882., 2850340., 2874798., 2899256., 4390866., 4426708., 4462550.,
      4498392., 7196394., 7251908., 7307422., 7362936., 6941354., 6998468.,
      7055582., 7112696., 4229842., 4267348., 4304854., 4342360., 4252946.,
      4291028., 4329110., 4367192., 7316266., 7374276., 7432286., 7490296.,
      7196394., 7251908., 7307422., 7362936., 3929106., 3963732., 3998358.,
      4032984., 2866842., 2892068., 2917294., 2942520., 4199442., 4237012.,
      4274582., 4312152., 4289234., 4323540., 4357846., 4392152., 2478490.,
      2498724., 2518958., 2539192.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x15x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7699722., 7755460., 7811198., 7866936., 6824138., 6879428., 6934718.,
      6990008., 7073098., 7132356., 7191614., 7250872., 7699722., 7755460.,
      7811198., 7866936., 7752698., 7819076., 7885454., 7951832., 7951290.,
      8016196., 8081102., 8146008., 8233018., 8301892., 8370766., 8439640.,
      7752698., 7819076., 7885454., 7951832., 7196394., 7251908., 7307422.,
      7362936., 6941354., 6998468., 7055582., 7112696., 7316266., 7374276.,
      7432286., 7490296., 7196394., 7251908., 7307422., 7362936.};
  const std::array<int, 4> in_shape = {{3, 15, 15, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x16x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      288148.,  406483.,  432047.,  276801.,  620092.,  856317.,  885841.,
      558327.,  972092.,  1328701., 1358225., 849079.,  449092.,  604527.,
      616539.,  377349.,  1423828., 1940323., 1965887., 1229361., 1940092.,
      2627757., 2657281., 1648647., 2292092., 3100141., 3129665., 1939399.,
      993412.,  1325247., 1337259., 812469.,  2559508., 3474163., 3499727.,
      2181921., 3260092., 4399197., 4428721., 2738967., 3612092., 4871581.,
      4901105., 3029719., 1537732., 2045967., 2057979., 1247589.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x16x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      848936.,  878460.,  1321320., 1350844., 2620376., 2649900.,
      3092760., 3122284., 4391816., 4421340., 4864200., 4893724.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x16x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      573356.,  576296.,  808731.,  812966.,  859551.,  864094.,  550613.,
      553602.,  1232748., 1240184., 1702107., 1712634., 1760671., 1771682.,
      1109493., 1116654., 1931116., 1944184., 2639131., 2657402., 2697695.,
      2716450., 1686069., 1698158., 888076.,  898184.,  1194963., 1209054.,
      1218679., 1233078., 745437.,  754698.,  2831276., 2847656., 3857931.,
      3880646., 3908751., 3931774., 2443973., 2458722., 3851628., 3880184.,
      5215947., 5255514., 5274511., 5314562., 3271653., 3297294., 4549996.,
      4584184., 6152971., 6200282., 6211535., 6259330., 3848229., 3878798.,
      1963276., 1986824., 2617923., 2650494., 2641639., 2674518., 1603917.,
      1624938., 5089196., 5119016., 6907131., 6948326., 6957951., 6999454.,
      4337333., 4363842., 6470508., 6520184., 8729787., 8798394., 8788351.,
      8857442., 5433813., 5477934., 7168876., 7224184., 9666811., 9743162.,
      9725375., 9802210., 6010389., 6059438., 3038476., 3075464., 4040883.,
      4091934., 4064599., 4115958., 2462397., 2495178.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x16x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1687466., 1697872., 1746030., 1756920., 2624490., 2642640.,
      2683054., 2701688., 5201306., 5240752., 5259870., 5299800.,
      6138330., 6185520., 6196894., 6244568., 8715146., 8783632.,
      8773710., 8842680., 9652170., 9728400., 9710734., 9787448.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x16x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1143772.,  1146712.,  1149652.,  1152592.,  1613227.,  1617462.,
      1621697.,  1625932.,  1714559.,  1719102.,  1723645.,  1728188.,
      1098237.,  1101226.,  1104215.,  1107204.,  2458060.,  2465496.,
      2472932.,  2480368.,  3393687.,  3404214.,  3414741.,  3425268.,
      3510331.,  3521342.,  3532353.,  3543364.,  2211825.,  2218986.,
      2226147.,  2233308.,  3849164.,  3862232.,  3875300.,  3888368.,
      5259991.,  5278262.,  5296533.,  5314804.,  5376635.,  5395390.,
      5414145.,  5432900.,  3360049.,  3372138.,  3384227.,  3396316.,
      1766044.,  1776152.,  1786260.,  1796368.,  2375835.,  2389926.,
      2404017.,  2418108.,  2422959.,  2437358.,  2451757.,  2466156.,
      1481613.,  1490874.,  1500135.,  1509396.,  5646172.,  5662552.,
      5678932.,  5695312.,  7693147.,  7715862.,  7738577.,  7761292.,
      7794479.,  7817502.,  7840525.,  7863548.,  4873197.,  4887946.,
      4902695.,  4917444.,  7674700.,  7703256.,  7731812.,  7760368.,
      10392327., 10431894., 10471461., 10511028., 10508971., 10549022.,
      10589073., 10629124., 6517665.,  6543306.,  6568947.,  6594588.,
      9065804.,  9099992.,  9134180.,  9168368.,  12258631., 12305942.,
      12353253., 12400564., 12375275., 12423070., 12470865., 12518660.,
      7665889.,  7696458.,  7727027.,  7757596.,  3903004.,  3926552.,
      3950100.,  3973648.,  5203275.,  5235846.,  5268417.,  5300988.,
      5250399.,  5283278.,  5316157.,  5349036.,  3186813.,  3207834.,
      3228855.,  3249876.,  2386652.,  2395992.,  2405332.,  2414672.,
      3269387.,  3282422.,  3295457.,  3308492.,  3370719.,  3384062.,
      3397405.,  3410748.,  2107357.,  2115946.,  2124535.,  2133124.,
      2163916.,  2176728.,  2189540.,  2202352.,  2944887.,  2962806.,
      2980725.,  2998644.,  3061531.,  3079934.,  3098337.,  3116740.,
      1888593.,  1900458.,  1912323.,  1924188.,  3153612.,  3163864.,
      3174116.,  3184368.,  4326839.,  4341238.,  4355637.,  4370036.,
      4443483.,  4458366.,  4473249.,  4488132.,  2785937.,  2795562.,
      2805187.,  2814812.,  1481116.,  1489432.,  1497748.,  1506064.,
      1998843.,  2010470.,  2022097.,  2033724.,  2045967.,  2057902.,
      2069837.,  2081772.,  1254253.,  1261946.,  1269639.,  1277332.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x16x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3364526.,  3374932.,  3385338.,  3395744.,  3481170.,  3492060.,
      3502950.,  3513840.,  5230830.,  5248980.,  5267130.,  5285280.,
      5347474.,  5366108.,  5384742.,  5403376.,  10363166., 10402612.,
      10442058., 10481504., 10479810., 10519740., 10559670., 10599600.,
      12229470., 12276660., 12323850., 12371040., 12346114., 12393788.,
      12441462., 12489136., 2915726.,  2933524.,  2951322.,  2969120.,
      3032370.,  3050652.,  3068934.,  3087216.,  4297678.,  4311956.,
      4326234.,  4340512.,  4414322.,  4429084.,  4443846.,  4458608.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x16x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2289896., 3230689., 3434585.,  2200541.,  4934952., 6814841., 7050065.,
      4443285., 7739688., 10578425., 10813649., 6759445., 3568040., 4802105.,
      4897585., 2996693., 2525672.,  3535873.,  3739769., 2378621., 4352552.,
      6003481., 6238705., 3918005.,  7038504.,  9637529., 9872753., 6180405.,
      3279528., 4420185., 4515665.,  2766197.,  2941672., 4088865., 4292761.,
      2714397., 3950376., 5439929.,  5675153.,  3550421., 6337320., 8696633.,
      8931857., 5601365., 2991016.,  4038265.,  4133745., 2535701.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x16x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6756035., 6991259., 10519619., 10754843., 5944675., 6179899.,
      9578723., 9813947., 5381123.,  5616347.,  8637827., 8873051.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x16x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1724952., 1736656., 2404067., 2420930., 2577155., 2595250., 1638455.,
      1650362., 2180216., 2197584., 3074543., 3099634., 3309583., 3336610.,
      2157715., 2175530., 2950264., 2973776., 4033519., 4067058., 4268559.,
      4304034., 2641555., 2664746., 1508248., 1519952., 2132371., 2149234.,
      2268851., 2286946., 1514023., 1525930., 2044440., 2056656., 2826851.,
      2844418., 2999939., 3018738., 1883063., 1895418., 2094200., 2114128.,
      2922863., 2951474., 3157903., 3188450., 2022419., 2042474., 3077240.,
      3099216., 4208495., 4239922., 4443535., 4476898., 2742803., 2764650.,
      1213336., 1225552., 1710355., 1727922., 1846835., 1865634., 1221031.,
      1233386., 2282008., 2294736., 3235299., 3253570., 3408387., 3427890.,
      2285367., 2298170., 2368632., 2391120., 3266799., 3298930., 3501839.,
      3535906., 2202515., 2224810., 3122296., 3142736., 4369135., 4398450.,
      4604175., 4635426., 3001747., 3022250., 1098648., 1111376., 1536147.,
      1554418., 1672627., 1692130., 1085735., 1098538.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x16x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3015783., 3040390., 3250823., 3277366., 3974759., 4007814.,
      4209799., 4244790., 2864103., 2892230., 3099143., 3129206.,
      4149735., 4180678., 4384775., 4417654., 3208039., 3239686.,
      3443079., 3476662., 4310375., 4339206., 4545415., 4576182.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x16x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1556344., 1568048., 1579752., 1591456., 2150631., 2167494., 2184357.,
      2201220., 2311255., 2329350., 2347445., 2365540., 1523179., 1535086.,
      1546993., 1558900., 2320152., 2337520., 2354888., 2372256., 3149531.,
      3174622., 3199713., 3224804., 3384203., 3411230., 3438257., 3465284.,
      2120335., 2138150., 2155965., 2173780., 2936600., 2960112., 2983624.,
      3007136., 3944923., 3978462., 4012001., 4045540., 4179595., 4215070.,
      4250545., 4286020., 2623887., 2647078., 2670269., 2693460., 1465464.,
      1477168., 1488872., 1500576., 1999175., 2016038., 2032901., 2049764.,
      2139831., 2157926., 2176021., 2194116., 1365707., 1377614., 1389521.,
      1401428., 1686904., 1699120., 1711336., 1723552., 2290983., 2308550.,
      2326117., 2343684., 2451607., 2470406., 2489205., 2508004., 1553195.,
      1565550., 1577905., 1590260., 2440472., 2460400., 2480328., 2500256.,
      3383323., 3411934., 3440545., 3469156., 3617995., 3648542., 3679089.,
      3709636., 2420943., 2440998., 2461053., 2481108., 2831640., 2853616.,
      2875592., 2897568., 3789083., 3820510., 3851937., 3883364., 4023755.,
      4057118., 4090481., 4123844., 2483663., 2505510., 2527357., 2549204.,
      1251960., 1264176., 1276392., 1288608., 1678727., 1696294., 1713861.,
      1731428., 1819383., 1838182., 1856981., 1875780., 1123339., 1135694.,
      1148049., 1160404., 1915768., 1928496., 1941224., 1953952., 2664807.,
      2683078., 2701349., 2719620., 2825431., 2844934., 2864437., 2883940.,
      1898603., 1911406., 1924209., 1937012., 2626328., 2648816., 2671304.,
      2693792., 3559771., 3591902., 3624033., 3656164., 3794443., 3828510.,
      3862577., 3896644., 2434831., 2457126., 2479421., 2501716., 2824984.,
      2845424., 2865864., 2886304., 3866715., 3896030., 3925345., 3954660.,
      4101387., 4132638., 4163889., 4195140., 2658831., 2679334., 2699837.,
      2720340., 1398904., 1411632., 1424360., 1437088., 1853895., 1872166.,
      1890437., 1908708., 1994551., 2014054., 2033557., 2053060., 1196363.,
      1209166., 1221969., 1234772.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x16x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3090863., 3115470., 3140077., 3164684., 3325535., 3352078., 3378621.,
      3405164., 3886255., 3919310., 3952365., 3985420., 4120927., 4155918.,
      4190909., 4225900., 3324655., 3352782., 3380909., 3409036., 3559327.,
      3589390., 3619453., 3649516., 3730415., 3761358., 3792301., 3823244.,
      3965087., 3997966., 4030845., 4063724., 3501103., 3532750., 3564397.,
      3596044., 3735775., 3769358., 3802941., 3836524., 3808047., 3836878.,
      3865709., 3894540., 4042719., 4073486., 4104253., 4135020.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x16x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2766032., 4137158., 4831974., 3241630., 4588304., 6693118., 7637150.,
      4964022., 4588304., 6693118., 7637150., 4964022., 2557904., 3759462.,
      4307846., 2861502., 3389648., 4928582., 5623398., 3647518., 4671248.,
      6741118., 7685150., 4896822., 4671248., 6741118., 7685150., 4896822.,
      2821072., 4055270., 4603654., 2951998., 4209872., 6186950., 6881766.,
      4684190., 5311248., 7751678., 8695710., 5775798., 5311248., 7751678.,
      8695710., 5775798., 3280848., 4818022., 5366406., 3673278.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x16x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6457110., 7401142., 6457110., 7401142., 6505110., 7449142.,
      6505110., 7449142., 7515670., 8459702., 7515670., 8459702.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x16x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2980144., 3002272., 4254890., 4288396., 4902314., 4940748., 3174290.,
      3200316., 4739952., 4776480., 6705378., 6760444., 7651810., 7714620.,
      4864426., 4906860., 4739952., 4776480., 6705378., 6760444., 7651810.,
      7714620., 4864426., 4906860., 2618160., 2640288., 3749866., 3783372.,
      4317418., 4355852., 2776018., 2802044., 3504432., 3528608., 5114026.,
      5150348., 5761450., 5802700., 3984274., 4012092., 4772720., 4811296.,
      6864098., 6921980., 7810530., 7876156., 5186986., 5231212., 4772720.,
      4811296., 6864098., 6921980., 7810530., 7876156., 5186986., 5231212.,
      2552624., 2576800., 3552234., 3588556., 4119786., 4161036., 2496466.,
      2524284., 3635504., 3661728., 5334186., 5373324., 5981610., 6025676.,
      4220818., 4250428., 5133168., 5173792., 7375074., 7435772., 8321506.,
      8389948., 5566890., 5612908., 5133168., 5173792., 7375074., 7435772.,
      8321506., 8389948., 5566890., 5612908., 3404592., 3430816., 4812778.,
      4851916., 5380330., 5424396., 3478482., 3508092.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x16x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6468770., 6521900., 7415202., 7476076., 6468770., 6521900.,
      7415202., 7476076., 6627490., 6683436., 7573922., 7637612.,
      6627490., 6683436., 7573922., 7637612., 7138466., 7197228.,
      8084898., 8151404., 7138466., 7197228., 8084898., 8151404.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x16x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2390000., 2412128., 2434256., 2456384., 3964018., 3997524., 4031030.,
      4064536., 4582194., 4620628., 4659062., 4697496., 3007866., 3033892.,
      3059918., 3085944., 4354608., 4391136., 4427664., 4464192., 6664362.,
      6719428., 6774494., 6829560., 7615594., 7678404., 7741214., 7804024.,
      4837266., 4879700., 4922134., 4964568., 4354608., 4391136., 4427664.,
      4464192., 6664362., 6719428., 6774494., 6829560., 7615594., 7678404.,
      7741214., 7804024., 4837266., 4879700., 4922134., 4964568., 3070960.,
      3093088., 3115216., 3137344., 4242674., 4276180., 4309686., 4343192.,
      4848562., 4886996., 4925430., 4963864., 2991098., 3017124., 3043150.,
      3069176., 2519024., 2543200., 2567376., 2591552., 4434290., 4470612.,
      4506934., 4543256., 5052466., 5093716., 5134966., 5176216., 3708538.,
      3736356., 3764174., 3791992., 4352560., 4391136., 4429712., 4468288.,
      6782378., 6840260., 6898142., 6956024., 7733610., 7799236., 7864862.,
      7930488., 5152914., 5197140., 5241366., 5285592., 4352560., 4391136.,
      4429712., 4468288., 6782378., 6840260., 6898142., 6956024., 7733610.,
      7799236., 7864862., 7930488., 5152914., 5197140., 5241366., 5285592.,
      2806768., 2830944., 2855120., 2879296., 4106738., 4143060., 4179382.,
      4215704., 4712626., 4753876., 4795126., 4836376., 2888954., 2916772.,
      2944590., 2972408., 3434480., 3460704., 3486928., 3513152., 5199474.,
      5238612., 5277750., 5316888., 5817650., 5861716., 5905782., 5949848.,
      4048762., 4078372., 4107982., 4137592., 5005872., 5046496., 5087120.,
      5127744., 7604906., 7665604., 7726302., 7787000., 8556138., 8624580.,
      8693022., 8761464., 5845394., 5891412., 5937430., 5983448., 5005872.,
      5046496., 5087120., 5127744., 7604906., 7665604., 7726302., 7787000.,
      8556138., 8624580., 8693022., 8761464., 5845394., 5891412., 5937430.,
      5983448., 3066864., 3093088., 3119312., 3145536., 4790002., 4829140.,
      4868278., 4907416., 5395890., 5439956., 5484022., 5528088., 3737082.,
      3766692., 3796302., 3825912.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x16x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6426554., 6479684., 6532814., 6585944., 7377786., 7438660., 7499534.,
      7560408., 6426554., 6479684., 6532814., 6585944., 7377786., 7438660.,
      7499534., 7560408., 6544570., 6600516., 6656462., 6712408., 7495802.,
      7559492., 7623182., 7686872., 6544570., 6600516., 6656462., 6712408.,
      7495802., 7559492., 7623182., 7686872., 7367098., 7425860., 7484622.,
      7543384., 8318330., 8384836., 8451342., 8517848., 7367098., 7425860.,
      7484622., 7543384., 8318330., 8384836., 8451342., 8517848.};
  const std::array<int, 4> in_shape = {{3, 15, 16, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x18x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      280574.,  445214.,  470778.,  445830.,  268366.,  608762.,  949366.,
      978890.,  907500.,  538208.,  958034.,  1480798., 1510322., 1386660.,
      816200.,  444822.,  674366.,  686378.,  626010.,  360682.,  1405124.,
      2170784., 2196348., 2005080., 1181236., 1918532., 2942236., 2971760.,
      2704350., 1580678., 2267804., 3473668., 3503192., 3183510., 1858670.,
      987252.,  1485176., 1497188., 1353660., 774592.,  2529674., 3896354.,
      3921918., 3564330., 2094106., 3228302., 4935106., 4964630., 4501200.,
      2623148., 3577574., 5466538., 5496062., 4980360., 2901140., 1529682.,
      2295986., 2307998., 2081310., 1188502.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x18x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      949366.,  978890.,  1480798., 1510322., 2942236., 2971760.,
      3473668., 3503192., 4935106., 4964630., 5466538., 5496062.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x18x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      558306.,   561148.,  885808.,  890428.,  936628.,   941556.,   886935.,
      891660.,   533813.,  536732.,  1210286., 1217524.,  1887116.,  1898732.,
      1945680.,  1957780., 1803615., 1815000., 1069453.,  1076416.,  1903286.,
      1916068.,  2941268., 2961596., 2999832., 3020644.,  2754015.,  2773320.,
      1620685.,  1632400., 879746.,  889644.,  1333024.,  1348732.,  1356740.,
      1372756.,  1237215., 1252020., 712397.,  721364.,   2794176.,  2810248.,
      4316158.,  4341568., 4366978., 4392696., 3986535.,  4010160.,  2348213.,
      2362472.,  3809036., 3837064., 5840186., 5884472.,  5898750.,  5943520.,
      5367615.,  5408700., 3136573., 3161356., 4502036.,  4535608.,  6894338.,
      6947336.,  6952902., 7006384., 6318015., 6367020.,  3687805.,  3717340.,
      1951376.,  1974504., 2933854., 2970352., 2957570.,  2994376.,  2673615.,
      2707320.,  1528877., 1549184., 5030046., 5059348.,  7746508.,  7792708.,
      7797328.,  7843836., 7086135., 7128660., 4162613.,  4188212.,  6407786.,
      6456604.,  9793256., 9870212., 9851820., 9929260.,  8931615.,  9002400.,
      5203693.,  5246296., 7100786., 7155148., 10847408., 10933076., 10905972.,
      10992124., 9882015., 9960720., 5754925., 5802280.,  3023006.,  3059364.,
      4534684.,  4591972., 4558400., 4615996., 4110015.,  4162620.,  2345357.,
      2377004.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x18x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1887116., 1898732., 1945680.,  1957780.,  2941268.,  2961596.,
      2999832., 3020644., 5840186.,  5884472.,  5898750.,  5943520.,
      6894338., 6947336., 6952902.,  7006384.,  9793256.,  9870212.,
      9851820., 9929260., 10847408., 10933076., 10905972., 10992124.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x18x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1113770.,  1116612.,  1119454.,  1122296.,  1766996.,  1771616.,
      1776236.,  1780856.,  1868328.,  1873256.,  1878184.,  1883112.,
      1769145.,  1773870.,  1778595.,  1783320.,  1064707.,  1067626.,
      1070545.,  1073464.,  2413334.,  2420572.,  2427810.,  2435048.,
      3762616.,  3774232.,  3785848.,  3797464.,  3879260.,  3891360.,
      3903460.,  3915560.,  3595845.,  3607230.,  3618615.,  3630000.,
      2131943.,  2138906.,  2145869.,  2152832.,  3793790.,  3806572.,
      3819354.,  3832136.,  5862208.,  5882536.,  5902864.,  5923192.,
      5978852.,  5999664.,  6020476.,  6041288.,  5488725.,  5508030.,
      5527335.,  5546640.,  3229655.,  3241370.,  3253085.,  3264800.,
      1749594.,  1759492.,  1769390.,  1779288.,  2650340.,  2666048.,
      2681756.,  2697464.,  2697464.,  2713480.,  2729496.,  2745512.,
      2459625.,  2474430.,  2489235.,  2504040.,  1415827.,  1424794.,
      1433761.,  1442728.,  5572280.,  5588352.,  5604424.,  5620496.,
      8606906.,  8632316.,  8657726.,  8683136.,  8708238.,  8733956.,
      8759674.,  8785392.,  7949445.,  7973070.,  7996695.,  8020320.,
      4682167.,  4696426.,  4710685.,  4724944.,  7590044.,  7618072.,
      7646100.,  7674128.,  11636086., 11680372., 11724658., 11768944.,
      11752730., 11797500., 11842270., 11887040., 10694145., 10735230.,
      10776315., 10817400., 6248363.,  6273146.,  6297929.,  6322712.,
      7289604.,  7319592.,  7349580.,  7379568.,  10474238., 10520068.,
      10565898., 10611728., 9732770.,  9777036.,  9821302.,  9865568.,
      8112145.,  8150910.,  8189675.,  8228440.,  4710299.,  4733690.,
      4757081.,  4780472.,  2829512.,  2849056.,  2868600.,  2888144.,
      3831338.,  3860668.,  3889998.,  3919328.,  3380798.,  3408388.,
      3435978.,  3463568.,  2640885.,  2664350.,  2687815.,  2711280.,
      1483015.,  1497178.,  1511341.,  1525504.,  1576134.,  1580348.,
      1584562.,  1588776.,  2476320.,  2483096.,  2489872.,  2496648.,
      2577652.,  2584736.,  2591820.,  2598904.,  2410065.,  2416750.,
      2423435.,  2430120.,  1439851.,  1443946.,  1448041.,  1452136.,
      2950178.,  2959572.,  2968966.,  2978360.,  4579124.,  4594128.,
      4609132.,  4624136.,  4695768.,  4711256.,  4726744.,  4742232.,
      4331965.,  4346430.,  4360895.,  4375360.,  2558831.,  2567642.,
      2576453.,  2585264.,  4330634.,  4345572.,  4360510.,  4375448.,
      6678716.,  6702432.,  6726148.,  6749864.,  6795360.,  6819560.,
      6843760.,  6867960.,  6224845.,  6247230.,  6269615.,  6292000.,
      3656543.,  3670106.,  3683669.,  3697232.,  1970486.,  1981756.,
      1993026.,  2004296.,  2980208.,  2998072.,  3015936.,  3033800.,
      3027332.,  3045504.,  3063676.,  3081848.,  2755585.,  2772350.,
      2789115.,  2805880.,  1583995.,  1594138.,  1604281.,  1614424.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x18x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3762616.,  3774232.,  3785848.,  3797464.,  3879260.,  3891360.,
      3903460.,  3915560.,  5862208.,  5882536.,  5902864.,  5923192.,
      5978852.,  5999664.,  6020476.,  6041288.,  11636086., 11680372.,
      11724658., 11768944., 11752730., 11797500., 11842270., 11887040.,
      10474238., 10520068., 10565898., 10611728., 9732770.,  9777036.,
      9821302.,  9865568.,  4579124.,  4594128.,  4609132.,  4624136.,
      4695768.,  4711256.,  4726744.,  4742232.,  6678716.,  6702432.,
      6726148.,  6749864.,  6795360.,  6819560.,  6843760.,  6867960.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x18x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2230627., 3539767., 3743663., 3545710., 2134370.,  4845995., 7557055.,
      7792279., 7224030., 4284082., 6893339., 10103023., 9418695., 8681150.,
      5106898., 3069403., 4300303., 3836679., 3513950.,  2013554., 2695735.,
      4253403., 4457299., 4190550., 2511866., 5387151.,  8380339., 8615563.,
      7966310., 4714666., 6482175., 9338595., 8711611.,  7288390., 4281034.,
      2701167., 3677555., 3271275., 2579910., 1468298.,  3160843., 4967039.,
      5170935., 4835390., 2889362., 5928307., 9203623.,  9438847., 8708590.,
      5145250., 5492963., 8470231., 8104879., 6860238.,  3590338., 2025219.,
      3040983., 2806223., 2250030., 1058210.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x18x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7557055., 7792279., 10103023., 9418695., 8380339., 8615563.,
      9338595., 8711611., 9203623.,  9438847., 8470231., 8104879.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x18x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1685391., 1696710., 2624395., 2642798., 2797483., 2817118., 2671182.,
      2690012., 1576786., 1588420., 2122635., 2138198., 3331959., 3356798.,
      3509655., 3535406., 3414854., 3439804., 2050778., 2066276., 2590667.,
      2612534., 3625399., 3658974., 3327959., 3360398., 3190598., 3221628.,
      1852634., 1871780., 1749567., 1762486., 2745339., 2765086., 2849051.,
      2867982., 2763950., 2782140., 1679602., 1690852., 1966719., 1980270.,
      2672123., 2692278., 2435611., 2454950., 2181326., 2198956., 1297234.,
      1308148., 2570875., 2589214., 3989735., 4017766., 4175623., 4203542.,
      4018758., 4044748., 2416730., 2432852., 2490043., 2512638., 3329831.,
      3363014., 3016007., 3047030., 2565702., 2592652., 1505882., 1522580.,
      1999535., 2013150., 3056107., 3076582., 2692875., 2712534., 2104366.,
      2121356., 1219570., 1230100., 1712495., 1725718., 2582635., 2603518.,
      2403467., 2423534., 2064206., 2081660., 1152850., 1163044., 3007851.,
      3027430., 4747863., 4779086., 4597879., 4628990., 3897670., 3925724.,
      2131418., 2148164., 2071979., 2092230., 3162263., 3194542., 3035831.,
      3066462., 2653510., 2679452., 1429466., 1443716., 1681183., 1693958.,
      2567131., 2587822., 2374907., 2395294., 1915822., 1933660., 894706.,
      904516.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x18x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3331959., 3356798., 3509655., 3535406., 3625399., 3658974.,
      3327959., 3360398., 3989735., 4017766., 4175623., 4203542.,
      3329831., 3363014., 3016007., 3047030., 4747863., 4779086.,
      4597879., 4628990., 3162263., 3194542., 3035831., 3066462.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x18x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1514471., 1525790., 1537109., 1548428., 2345011., 2363414., 2381817.,
      2400220., 2505635., 2525270., 2544905., 2564540., 2422798., 2441628.,
      2460458., 2479288., 1440050., 1451684., 1463318., 1474952., 2017099.,
      2032662., 2048225., 2063788., 2991847., 3016686., 3041525., 3066364.,
      3112855., 3138606., 3164357., 3190108., 3076118., 3101068., 3126018.,
      3150968., 1762090., 1777588., 1793086., 1808584., 2840363., 2862230.,
      2884097., 2905964., 4086087., 4119662., 4153237., 4186812., 4045303.,
      4077742., 4110181., 4142620., 3973206., 4004236., 4035266., 4066296.,
      2296042., 2315188., 2334334., 2353480., 1682951., 1695870., 1708789.,
      1721708., 2476755., 2496502., 2516249., 2535996., 2553923., 2572854.,
      2591785., 2610716., 2526030., 2544220., 2562410., 2580600., 1444850.,
      1456100., 1467350., 1478600., 1790223., 1803774., 1817325., 1830876.,
      2448955., 2469110., 2489265., 2509420., 2316715., 2336054., 2355393.,
      2374732., 2167230., 2184860., 2202490., 2220120., 1324034., 1334948.,
      1345862., 1356776., 2380371., 2398710., 2417049., 2435388., 3487055.,
      3515086., 3543117., 3571148., 3625471., 3653390., 3681309., 3709228.,
      3551750., 3577740., 3603730., 3629720., 2063290., 2079412., 2095534.,
      2111656., 3025459., 3048054., 3070649., 3093244., 3988911., 4022094.,
      4055277., 4088460., 3654239., 3685262., 3716285., 3747308., 3307078.,
      3334028., 3360978., 3387928., 1961338., 1978036., 1994734., 2011432.,
      1895471., 1909086., 1922701., 1936316., 2769883., 2790358., 2810833.,
      2831308., 2437451., 2457110., 2476769., 2496428., 1971966., 1988956.,
      2005946., 2022936., 1053890., 1064420., 1074950., 1085480., 1652791.,
      1666014., 1679237., 1692460., 2541635., 2562518., 2583401., 2604284.,
      2524083., 2544150., 2564217., 2584284., 2393966., 2411420., 2428874.,
      2446328., 1478354., 1488548., 1498742., 1508936., 2722651., 2742230.,
      2761809., 2781388., 4182967., 4214190., 4245413., 4276636., 4042855.,
      4073966., 4105077., 4136188., 3493878., 3521932., 3549986., 3578040.,
      1848394., 1865140., 1881886., 1898632., 2578747., 2598998., 2619249.,
      2639500., 3886103., 3918382., 3950661., 3982940., 3794631., 3825262.,
      3855893., 3886524., 3014710., 3040652., 3066594., 3092536., 1380874.,
      1395124., 1409374., 1423624., 1628247., 1641022., 1653797., 1666572.,
      2381539., 2402230., 2422921., 2443612., 2259539., 2279926., 2300313.,
      2320700., 1964718., 1982556., 2000394., 2018232., 933266.,  943076.,
      952886.,  962696.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x18x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2991847., 3016686., 3041525., 3066364., 3112855., 3138606., 3164357.,
      3190108., 4086087., 4119662., 4153237., 4186812., 4045303., 4077742.,
      4110181., 4142620., 3487055., 3515086., 3543117., 3571148., 3625471.,
      3653390., 3681309., 3709228., 3988911., 4022094., 4055277., 4088460.,
      3654239., 3685262., 3716285., 3747308., 4182967., 4214190., 4245413.,
      4276636., 4042855., 4073966., 4105077., 4136188., 3886103., 3918382.,
      3950661., 3982940., 3794631., 3825262., 3855893., 3886524.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x18x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3083590., 4924782., 5273486., 5145332., 3111724., 5326174., 8267046.,
      7738054., 6590404., 3411164., 4898206., 7219814., 6952966., 7013188.,
      4266332., 2963430., 4752782., 4844974., 4586420., 2639980., 3853942.,
      5495518., 5317374., 4995988., 3099020., 4622542., 7350230., 8060278.,
      7376868., 4245436., 5521166., 7936790., 7778998., 6929252., 3936316.,
      3248406., 5090046., 4636958., 3586132., 2094796., 3866022., 6189646.,
      6177902., 5748788., 3431404., 4854334., 7742598., 7618598., 6737924.,
      3736220., 5003390., 7505350., 7263078., 6667140., 3703580., 2842694.,
      4422254., 4212366., 3594484., 1737004.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x18x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8267046., 7738054., 7219814., 6952966., 7350230., 8060278.,
      7936790., 7778998., 7742598., 7618598., 7505350., 7263078.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x18x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3234834., 3258508., 4846058., 4884700., 4805354., 4844828., 4439612.,
      4475880., 2552036., 2573912., 4928042., 4966588., 7417122., 7479372.,
      7261730., 7322508., 6888588., 6943112., 3802132., 3833272., 4957226.,
      4995388., 7388962., 7449292., 7495714., 7554572., 7634060., 7690376.,
      4527124., 4560568., 3678802., 3704780., 5630762., 5671708., 5555242.,
      5593948., 4819388., 4855144., 2375012., 2395352., 3371922., 3398380.,
      4715882., 4756412., 4671082., 4711420., 4411964., 4447528., 2724068.,
      2745112., 5069226., 5107612., 7821474., 7882156., 8567202., 8630508.,
      7632012., 7688648., 4272148., 4305784., 5913514., 5954588., 8174242.,
      8236076., 7973794., 8035180., 7427212., 7481544., 4243476., 4277368.,
      3364306., 3389996., 4995754., 5035516., 4613034., 4653628., 3515836.,
      3550888., 1824100., 1845656., 3308306., 3332428., 5359850., 5399196.,
      5646826., 5687004., 5662268., 5699176., 3584228., 3606488., 4985130.,
      5022332., 7959586., 8019724., 8086818., 8148556., 7359628., 7418376.,
      4152340., 4188472., 5378858., 5418748., 7972386., 8036748., 7866146.,
      7929036., 6597772., 6654216., 3107860., 3140152., 2718034., 2742412.,
      3922474., 3962076., 3765034., 3804444., 3441084., 3477480., 1650020.,
      1670744.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x18x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7417122., 7479372., 7261730., 7322508., 7388962., 7449292.,
      7495714., 7554572., 7821474., 7882156., 8567202., 8630508.,
      8174242., 8236076., 7973794., 8035180., 7959586., 8019724.,
      8086818., 8148556., 7972386., 8036748., 7866146., 7929036.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x15x18x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2736042., 2759716., 2783390., 2807064., 4596450., 4635092., 4673734.,
      4712376., 4891042., 4930516., 4969990., 5009464., 4645580., 4681848.,
      4718116., 4754384., 2493012., 2514888., 2536764., 2558640., 4929986.,
      4968532., 5007078., 5045624., 7879962., 7942212., 8004462., 8066712.,
      7423194., 7483972., 7544750., 7605528., 7152156., 7206680., 7261204.,
      7315728., 3942020., 3973160., 4004300., 4035440., 4923202., 4961364.,
      4999526., 5037688., 7792794., 7853124., 7913454., 7973784., 7598170.,
      7657028., 7715886., 7774744., 7428892., 7485208., 7541524., 7597840.,
      4472196., 4505640., 4539084., 4572528., 3333930., 3359908., 3385886.,
      3411864., 5219938., 5260884., 5301830., 5342776., 5071138., 5109844.,
      5148550., 5187256., 4516812., 4552568., 4588324., 4624080., 2700628.,
      2720968., 2741308., 2761648., 3384266., 3410724., 3437182., 3463640.,
      5128834., 5169364., 5209894., 5250424., 5416258., 5456596., 5496934.,
      5537272., 4509068., 4544632., 4580196., 4615760., 2682260., 2703304.,
      2724348., 2745392., 5163362., 5201748., 5240134., 5278520., 7780922.,
      7841604., 7902286., 7962968., 8335866., 8399172., 8462478., 8525784.,
      7170524., 7227160., 7283796., 7340432., 4322500., 4356136., 4389772.,
      4423408., 5472994., 5514068., 5555142., 5596216., 7666106., 7727940.,
      7789774., 7851608., 7380346., 7441732., 7503118., 7564504., 6861532.,
      6915864., 6970196., 7024528., 4395972., 4429864., 4463756., 4497648.,
      2901834., 2927524., 2953214., 2978904., 4999682., 5039444., 5079206.,
      5118968., 4757698., 4798292., 4838886., 4879480., 4122252., 4157304.,
      4192356., 4227408., 2572436., 2593992., 2615548., 2637104., 3111914.,
      3136036., 3160158., 3184280., 5115426., 5154772., 5194118., 5233464.,
      5016802., 5056980., 5097158., 5137336., 4829260., 4866168., 4903076.,
      4939984., 3197140., 3219400., 3241660., 3263920., 4160770., 4197972.,
      4235174., 4272376., 7410522., 7470660., 7530798., 7590936., 7515930.,
      7577668., 7639406., 7701144., 6992284., 7051032., 7109780., 7168528.,
      4571908., 4608040., 4644172., 4680304., 4355714., 4395604., 4435494.,
      4475384., 7661274., 7725636., 7789998., 7854360., 8089242., 8152132.,
      8215022., 8277912., 6617756., 6674200., 6730644., 6787088., 3404292.,
      3436584., 3468876., 3501168., 2855786., 2880164., 2904542., 2928920.,
      4688290., 4727892., 4767494., 4807096., 4635746., 4675156., 4714566.,
      4753976., 4610380., 4646776., 4683172., 4719568., 1889236., 1909960.,
      1930684., 1951408.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x15x18x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7879962., 7942212., 8004462., 8066712., 7423194., 7483972., 7544750.,
      7605528., 7792794., 7853124., 7913454., 7973784., 7598170., 7657028.,
      7715886., 7774744., 7780922., 7841604., 7902286., 7962968., 8335866.,
      8399172., 8462478., 8525784., 7666106., 7727940., 7789774., 7851608.,
      7380346., 7441732., 7503118., 7564504., 7410522., 7470660., 7530798.,
      7590936., 7515930., 7577668., 7639406., 7701144., 7661274., 7725636.,
      7789998., 7854360., 8089242., 8152132., 8215022., 8277912.};
  const std::array<int, 4> in_shape = {{3, 15, 18, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x15x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      300272.,  476080.,  503360.,  321440.,  583352.,  909436.,  938960.,
      590744.,  874412.,  1352296., 1381820., 863324.,  402192.,  610148.,
      622160.,  380632.,  1368752., 2112880., 2140160., 1336160., 1747592.,
      2680876., 2710400., 1681064., 2038652., 3123736., 3153260., 1953644.,
      884352.,  1330868., 1342880., 815752.,  2437232., 3749680., 3776960.,
      2350880., 2911832., 4452316., 4481840., 2771384., 3202892., 4895176.,
      4924700., 3043964., 1366512., 2051588., 2063600., 1250872.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x15x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      798721.,  828245.,  1241581., 1271105., 2570161., 2599685.,
      3013021., 3042545., 4341601., 4371125., 4784461., 4813985.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x15x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      597380.,  600544.,  947012.,  952160.,  1001220., 1006720., 639268.,
      642880.,  1159466., 1166704., 1807256., 1818872., 1865820., 1877920.,
      1173634., 1181488., 1736966., 1748824., 2685716., 2704592., 2744280.,
      2763640., 1714174., 1726648., 795368.,  804384.,  1205974., 1220296.,
      1229690., 1244320., 751856.,  761264.,  2720900., 2737504., 4199492.,
      4225760., 4253700., 4280320., 2655268., 2672320., 3469466., 3495184.,
      5321096., 5361752., 5379660., 5420800., 3335794., 3362128., 4046966.,
      4077304., 6199556., 6247472., 6258120., 6306520., 3876334., 3907288.,
      1747928., 1768704., 2628934., 2661736., 2652650., 2685760., 1610336.,
      1631504., 4844420., 4874464., 7451972., 7499360., 7506180., 7553920.,
      4671268., 4701760., 5779466., 5823664., 8834936., 8904632., 8893500.,
      8963680., 5497954., 5542768., 6356966., 6405784., 9713396., 9790352.,
      9771960., 9849400., 6038494., 6087928., 2700488., 2733024., 4051894.,
      4103176., 4075610., 4127200., 2468816., 2501744.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x15x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1587641., 1597442., 1646205., 1656490., 2466101., 2483162.,
      2524665., 2542210., 5101481., 5140322., 5160045., 5199370.,
      5979941., 6026042., 6038505., 6085090., 8615321., 8683202.,
      8673885., 8742250., 9493781., 9568922., 9552345., 9627970.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x15x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1191596.,  1194760.,  1197924.,  1201088.,  1888876.,  1894024.,
      1899172.,  1904320.,  1996940.,  2002440.,  2007940.,  2013440.,
      1274924.,  1278536.,  1282148.,  1285760.,  2311694.,  2318932.,
      2326170.,  2333408.,  3602896.,  3614512.,  3626128.,  3637744.,
      3719540.,  3731640.,  3743740.,  3755840.,  2339414.,  2347268.,
      2355122.,  2362976.,  3462074.,  3473932.,  3485790.,  3497648.,
      5352556.,  5371432.,  5390308.,  5409184.,  5469200.,  5488560.,
      5507920.,  5527280.,  3415874.,  3428348.,  3440822.,  3453296.,
      1581720.,  1590736.,  1599752.,  1608768.,  2397626.,  2411948.,
      2426270.,  2440592.,  2444750.,  2459380.,  2474010.,  2488640.,
      1494304.,  1503712.,  1513120.,  1522528.,  5425196.,  5441800.,
      5458404.,  5475008.,  8372716.,  8398984.,  8425252.,  8451520.,
      8480780.,  8507400.,  8534020.,  8560640.,  5293484.,  5310536.,
      5327588.,  5344640.,  6913214.,  6938932.,  6964650.,  6990368.,
      10601536., 10642192., 10682848., 10723504., 10718180., 10759320.,
      10800460., 10841600., 6645254.,  6671588.,  6697922.,  6724256.,
      8063594.,  8093932.,  8124270.,  8154608.,  12351196., 12399112.,
      12447028., 12494944., 12467840., 12516240., 12564640., 12613040.,
      7721714.,  7752668.,  7783622.,  7814576.,  3475080.,  3495856.,
      3516632.,  3537408.,  5225066.,  5257868.,  5290670.,  5323472.,
      5272190.,  5305300.,  5338410.,  5371520.,  3199504.,  3220672.,
      3241840.,  3263008.,  2183596.,  2193160.,  2202724.,  2212288.,
      3223916.,  3238536.,  3253156.,  3267776.,  3103628.,  3117576.,
      3131524.,  3145472.,  1936172.,  1945160.,  1954148.,  1963136.,
      1866606.,  1875988.,  1885370.,  1894752.,  2836144.,  2850544.,
      2864944.,  2879344.,  2904660.,  2918520.,  2932380.,  2946240.,
      1811894.,  1820868.,  1829842.,  1838816.,  2848538.,  2857932.,
      2867326.,  2876720.,  4419404.,  4434408.,  4449412.,  4464416.,
      4536048.,  4551536.,  4567024.,  4582512.,  2841762.,  2851772.,
      2861782.,  2871792.,  1329272.,  1336720.,  1344168.,  1351616.,
      2020634.,  2032492.,  2044350.,  2056208.,  2067758.,  2079924.,
      2092090.,  2104256.,  1266944.,  1274784.,  1282624.,  1290464.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x15x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3165481.,  3175282.,  3185083.,  3194884.,  3282125.,  3292410.,
      3302695.,  3312980.,  4915141.,  4932202.,  4949263.,  4966324.,
      5031785.,  5049330.,  5066875.,  5084420.,  10164121., 10202962.,
      10241803., 10280644., 10280765., 10320090., 10359415., 10398740.,
      11913781., 11959882., 12005983., 12052084., 12030425., 12077010.,
      12123595., 12170180., 2809865.,  2828082.,  2846299.,  2864516.,
      2833325.,  2851002.,  2868679.,  2886356.,  3981989.,  3995178.,
      4008367.,  4021556.,  4098633.,  4112306.,  4125979.,  4139652.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x15x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2387000., 3784792., 4002328.,  2555896.,  4642715., 7237615.,  7472839.,
      4701235., 6961955., 10765975., 11001199., 6872635., 3195535.,  4846611.,
      4942091., 3022663., 2502968.,  3879256.,  4005144., 2543352.,  4033979.,
      6298255., 6531943., 4122195.,  6343491.,  9825079., 10060303., 6293595.,
      2939951., 4464691., 4560171.,  2792167.,  2823736., 4268632.,  4255768.,
      2688504., 3583451., 5535535.,  5720583.,  3596915., 5725027.,  8884183.,
      9119407., 5714555., 2684367.,  4082771.,  4178251., 2561671.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x15x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6355525., 6590749., 9883885., 10119109., 5568229., 5779389.,
      8942989., 9178213., 5075845., 5215837.,  8002093., 8237317.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x15x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1864760., 1877360., 2918808., 2939312., 3119000., 3140912., 1988280.,
      2002672., 2258795., 2276918., 3421143., 3449054., 3500535., 3528334.,
      2219259., 2236262., 2803275., 2825542., 4022199., 4056622., 3937751.,
      3972062., 2271451., 2292598., 1387887., 1398814., 2218411., 2236198.,
      2354891., 2373910., 1565375., 1577870., 2018360., 2031472., 3076504.,
      3097520., 3185560., 3207472., 2009784., 2024176., 2093803., 2111094.,
      3145559., 3172382., 3125623., 3151822., 1926267., 1942438., 2915787.,
      2936710., 4237111., 4269934., 4054359., 4087070., 2306139., 2326454.,
      1134831., 1146206., 1755435., 1772902., 1834571., 1851222., 1223231.,
      1233102., 2376760., 2390384., 3529112., 3550640., 3499928., 3521840.,
      2188984., 2203376., 2241131., 2261174., 3335895., 3367262., 3169527.,
      3199758., 1888251., 1907174., 2923851., 2943430., 4615863., 4647086.,
      4465879., 4496990., 2545627., 2565110., 1039471., 1051294., 1578155.,
      1596838., 1558987., 1576854., 978367.,  989198.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x15x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3136735., 3163018., 3126015., 3152186., 4188351., 4221146.,
      4013791., 4046474., 3277919., 3308746., 3145343., 3175546.,
      4673599., 4704794., 4400735., 4431818., 4008927., 4044298.,
      3707391., 3741626., 3880895., 3910490., 4034015., 4063498.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x15x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1688376., 1700976., 1713576., 1726176., 2611992., 2632496., 2653000.,
      2673504., 2781592., 2803504., 2825416., 2847328., 1820728., 1835120.,
      1849512., 1863904., 2434315., 2452438., 2470561., 2488684., 3388327.,
      3416238., 3444149., 3472060., 3313751., 3341550., 3369349., 3397148.,
      1964683., 1981686., 1998689., 2015692., 2818715., 2840982., 2863249.,
      2885516., 4096503., 4130926., 4165349., 4199772., 4218535., 4252846.,
      4287157., 4321468., 2667035., 2688182., 2709329., 2730476., 1379375.,
      1390302., 1401229., 1412156., 2100699., 2118486., 2136273., 2154060.,
      2241355., 2260374., 2279393., 2298412., 1424815., 1437310., 1449805.,
      1462300., 1536312., 1549424., 1562536., 1575648., 2271512., 2292528.,
      2313544., 2334560., 2390424., 2412336., 2434248., 2456160., 1519672.,
      1534064., 1548456., 1562848., 2318155., 2335446., 2352737., 2370028.,
      3641063., 3667886., 3694709., 3721532., 3499415., 3525614., 3551813.,
      3578012., 1952971., 1969142., 1985313., 2001484., 2733787., 2754710.,
      2775633., 2796556., 3888951., 3921774., 3954597., 3987420., 3814375.,
      3847086., 3879797., 3912508., 2262107., 2282422., 2302737., 2323052.,
      1200495., 1211870., 1223245., 1234620., 1699355., 1716822., 1734289.,
      1751756., 1727371., 1744022., 1760673., 1777324., 1087215., 1097086.,
      1106957., 1116828., 1793848., 1807472., 1821096., 1834720., 2520856.,
      2542384., 2563912., 2585440., 2494872., 2516784., 2538696., 2560608.,
      1534008., 1548400., 1562792., 1577184., 2298763., 2318806., 2338849.,
      2358892., 3378215., 3409582., 3440949., 3472316., 3337431., 3367662.,
      3397893., 3428124., 2185483., 2204406., 2223329., 2242252., 2702107.,
      2721686., 2741265., 2760844., 4140151., 4171374., 4202597., 4233820.,
      4000039., 4031150., 4062261., 4093372., 2266779., 2286262., 2305745.,
      2325228., 1337007., 1348830., 1360653., 1372476., 1867867., 1886550.,
      1905233., 1923916., 1699275., 1717142., 1735009., 1752876., 940591.,
      951422.,  962253.,  973084.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x15x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3696659., 3722942., 3749225., 3775508., 3441859., 3468030., 3494201.,
      3520372., 3864163., 3896958., 3929753., 3962548., 3805971., 3838654.,
      3871337., 3904020., 3335507., 3366334., 3397161., 3427988., 3361795.,
      3391998., 3422201., 3452404., 4197283., 4228478., 4259673., 4290868.,
      3942483., 3973566., 4004649., 4035732., 4154003., 4189374., 4224745.,
      4260116., 3842883., 3877118., 3911353., 3945588., 3547363., 3576958.,
      3606553., 3636148., 3620243., 3649726., 3679209., 3708692.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x15x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3523344., 5608656., 6164432., 4167184., 4909278., 7198374., 7253574.,
      4635134., 4804798., 7173382., 7198374., 4300766., 2534678., 4105470.,
      4130078., 2593462., 3680016., 5454032., 5630416., 3679760., 4882526.,
      6877734., 6537158., 3934078., 4814398., 7102086., 6877734., 3979102.,
      2784918., 4318334., 4306590., 2646582., 4655888., 6479056., 6181840.,
      3823120., 5631454., 8084390., 7253830., 4061950., 5323198., 8347142.,
      8084390., 4580574., 3141654., 5075454., 5303838., 3307446.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x15x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6778382., 6473134., 7103598., 6778382., 7837582., 7091502.,
      8512494., 7837582., 8569102., 8336558., 8450926., 8569102.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x15x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3381680., 3407392., 4938224., 4979104., 5130736., 5173152., 3427760.,
      3456544., 5468458., 5509052., 7737378., 7799628., 7962914., 8024716.,
      4926698., 4965884., 5081130., 5119868., 7573282., 7634956., 7737378.,
      7799628., 4832234., 4870588., 2661330., 2683436., 4159658., 4196860.,
      4469162., 4508220., 2855058., 2880364., 3692976., 3720736., 5151216.,
      5194144., 4848112., 4891552., 2911664., 2940448., 4959530., 4996796.,
      7429154., 7486028., 7126306., 7181708., 3987690., 4022524., 4903978.,
      4942460., 7236386., 7295756., 7429154., 7486028., 4388842., 4423868.,
      2635730., 2659628., 3798186., 3836156., 3775914., 3812668., 2243730.,
      2265708., 3807664., 3837472., 5364208., 5409184., 5425648., 5470112.,
      3657136., 3685920., 5208362., 5249468., 7280674., 7343436., 6785314.,
      6845580., 4175082., 4212732., 5197866., 5239164., 7690018., 7754252.,
      7280674., 7343436., 4211690., 4250556., 3347410., 3373100., 5046442.,
      5088252., 4979114., 5020732., 2840722., 2866540.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x15x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7522402., 7578140., 7027042., 7082332., 7268194., 7327452.,
      7522402., 7578140., 7079010., 7140636., 6751586., 6811740.,
      7787362., 7851484., 7079010., 7140636., 8077410., 8144924.,
      7729506., 7794524., 8511330., 8580316., 8077410., 8144924.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x15x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3003120., 3028832., 3054544., 3080256., 5294640., 5335520., 5376400.,
      5417280., 5268528., 5310944., 5353360., 5395776., 3385072., 3413856.,
      3442640., 3471424., 4845506., 4886100., 4926694., 4967288., 7504666.,
      7566916., 7629166., 7691416., 8070874., 8132676., 8194478., 8256280.,
      4813506., 4852692., 4891878., 4931064., 4760834., 4799572., 4838310.,
      4877048., 7324506., 7386180., 7447854., 7509528., 7504666., 7566916.,
      7629166., 7691416., 4936706., 4975060., 5013414., 5051768., 3060042.,
      3082148., 3104254., 3126360., 4677634., 4714836., 4752038., 4789240.,
      4770498., 4809556., 4848614., 4887672., 2941002., 2966308., 2991614.,
      3016920., 3492592., 3520352., 3548112., 3575872., 5259824., 5302752.,
      5345680., 5388608., 5029936., 5073376., 5116816., 5160256., 3008240.,
      3037024., 3065808., 3094592., 4224194., 4261460., 4298726., 4335992.,
      7483418., 7540292., 7597166., 7654040., 6993882., 7049284., 7104686.,
      7160088., 3922882., 3957716., 3992550., 4027384., 4275714., 4314196.,
      4352678., 4391160., 6980698., 7040068., 7099438., 7158808., 7483418.,
      7540292., 7597166., 7654040., 4249858., 4284884., 4319910., 4354936.,
      2744906., 2768804., 2792702., 2816600., 4216066., 4254036., 4292006.,
      4329976., 4172738., 4209492., 4246246., 4283000., 2704714., 2726692.,
      2748670., 2770648., 3588848., 3618656., 3648464., 3678272., 5225008.,
      5269984., 5314960., 5359936., 5200944., 5245408., 5289872., 5334336.,
      3581680., 3610464., 3639248., 3668032., 5373378., 5414484., 5455590.,
      5496696., 7770394., 7833156., 7895918., 7958680., 6896858., 6957124.,
      7017390., 7077656., 4229314., 4266964., 4304614., 4342264., 4991746.,
      5033044., 5074342., 5115640., 8472922., 8537156., 8601390., 8665624.,
      7770394., 7833156., 7895918., 7958680., 4350466., 4389332., 4428198.,
      4467064., 2855754., 2881444., 2907134., 2932824., 5135874., 5177684.,
      5219494., 5261304., 5525698., 5567316., 5608934., 5650552., 3042890.,
      3068708., 3094526., 3120344.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x15x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7699722., 7755460., 7811198., 7866936., 6824138., 6879428., 6934718.,
      6990008., 7073098., 7132356., 7191614., 7250872., 7699722., 7755460.,
      7811198., 7866936., 7396874., 7458500., 7520126., 7581752., 6858186.,
      6918340., 6978494., 7038648., 8696394., 8760516., 8824638., 8888760.,
      7396874., 7458500., 7520126., 7581752., 7880458., 7947972., 8015486.,
      8083000., 7826122., 7891140., 7956158., 8021176., 8369994., 8438980.,
      8507966., 8576952., 7880458., 7947972., 8015486., 8083000.};
  const std::array<int, 4> in_shape = {{3, 16, 15, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x16x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      365360.,  511852.,  539132.,  343700.,  708092.,  974413.,  1003937.,
      631015.,  1060092., 1446797., 1476321., 921767.,  485380.,  652575.,
      664587.,  406357.,  1659696., 2257772., 2285052., 1426068., 2116092.,
      2863949., 2893473., 1794023., 2468092., 3336333., 3365857., 2084775.,
      1065988., 1421343., 1433355., 870485.,  2954032., 4003692., 4030972.,
      2508436., 3524092., 4753485., 4783009., 2957031., 3876092., 5225869.,
      5255393., 3247783., 1646596., 2190111., 2202123., 1334613.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x16x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      848936.,  878460.,  1321320., 1350844., 2738472., 2767996.,
      3210856., 3240380., 4628008., 4657532., 5100392., 5129916.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x16x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      726848.,   730720.,   1018160., 1023704., 1072368., 1078264.,  683536.,
      687400.,   1407340.,  1416184., 1936363., 1948826., 1994927.,  2007874.,
      1253637.,  1262030.,  2105708., 2120184., 2873387., 2893594.,  2931951.,
      2952642.,  1830213.,  1843534., 959756.,  970760.,  1289827.,  1305150.,
      1313543.,  1329174.,  802669.,  812714.,  3299136., 3319392.,  4487472.,
      4515544.,  4541680.,  4570104., 2833936., 2852136., 4200812.,  4232184.,
      5684459.,  5727898.,  5743023., 5786946., 3559941., 3588046.,  4899180.,
      4936184.,  6621483.,  6672666., 6680047., 6731714., 4136517.,  4169550.,
      2106636.,  2131976.,  2807651., 2842686., 2831367., 2866710.,  1718381.,
      1740970.,  5871424.,  5908064., 7956784., 8007384., 8010992.,  8061944.,
      4984336.,  5016872.,  6994284., 7048184., 9432555., 9506970.,  9491119.,
      9566018.,  5866245.,  5914062., 7692652., 7752184., 10369579., 10451738.,
      10428143., 10510786., 6442821., 6495566., 3253516., 3293192.,  4325475.,
      4380222.,  4349191.,  4404246., 2634093., 2669226.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x16x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1687466., 1697872., 1746030.,  1756920.,  2624490.,  2642640.,
      2683054., 2701688., 5435562.,  5476944.,  5494126.,  5535992.,
      6372586., 6421712., 6431150.,  6480760.,  9183658.,  9256016.,
      9242222., 9315064., 10120682., 10200784., 10179246., 10259832.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x16x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1449824.,  1453696.,  1457568.,  1461440.,  2030776.,  2036320.,
      2041864.,  2047408.,  2138840.,  2144736.,  2150632.,  2156528.,
      1363208.,  1367072.,  1370936.,  1374800.,  2805836.,  2814680.,
      2823524.,  2832368.,  3860263.,  3872726.,  3885189.,  3897652.,
      3976907.,  3989854.,  4002801.,  4015748.,  2498881.,  2507274.,
      2515667.,  2524060.,  4196940.,  4211416.,  4225892.,  4240368.,
      5726567.,  5746774.,  5766981.,  5787188.,  5843211.,  5863902.,
      5884593.,  5905284.,  3647105.,  3660426.,  3673747.,  3687068.,
      1908508.,  1919512.,  1930516.,  1941520.,  2564331.,  2579654.,
      2594977.,  2610300.,  2611455.,  2627086.,  2642717.,  2658348.,
      1595293.,  1605338.,  1615383.,  1625428.,  6578016.,  6598272.,
      6618528.,  6638784.,  8946872.,  8974944.,  9003016.,  9031088.,
      9054936.,  9083360.,  9111784.,  9140208.,  5649672.,  5667872.,
      5686072.,  5704272.,  8370252.,  8401624.,  8432996.,  8464368.,
      11325479., 11368918., 11412357., 11455796., 11442123., 11486046.,
      11529969., 11573892., 7091777.,  7119882.,  7147987.,  7176092.,
      9761356.,  9798360.,  9835364.,  9872368.,  13191783., 13242966.,
      13294149., 13345332., 13308427., 13360094., 13411761., 13463428.,
      8240001.,  8273034.,  8306067.,  8339100.,  4187932.,  4213272.,
      4238612.,  4263952.,  5580267.,  5615302.,  5650337.,  5685372.,
      5627391.,  5662734.,  5698077.,  5733420.,  3414173.,  3436762.,
      3459351.,  3481940.,  1449824.,  1453696.,  1457568.,  1461440.,
      2030776.,  2036320.,  2041864.,  2047408.,  2138840.,  2144736.,
      2150632.,  2156528.,  1363208.,  1367072.,  1370936.,  1374800.,
      2805836.,  2814680.,  2823524.,  2832368.,  3860263.,  3872726.,
      3885189.,  3897652.,  3976907.,  3989854.,  4002801.,  4015748.,
      2498881.,  2507274.,  2515667.,  2524060.,  4196940.,  4211416.,
      4225892.,  4240368.,  5726567.,  5746774.,  5766981.,  5787188.,
      5843211.,  5863902.,  5884593.,  5905284.,  3647105.,  3660426.,
      3673747.,  3687068.,  1908508.,  1919512.,  1930516.,  1941520.,
      2564331.,  2579654.,  2594977.,  2610300.,  2611455.,  2627086.,
      2642717.,  2658348.,  1595293.,  1605338.,  1615383.,  1625428.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x16x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3364526.,  3374932.,  3385338.,  3395744.,  3481170.,  3492060.,
      3502950.,  3513840.,  5230830.,  5248980.,  5267130.,  5285280.,
      5347474.,  5366108.,  5384742.,  5403376.,  10829742., 10871124.,
      10912506., 10953888., 10946386., 10988252., 11030118., 11071984.,
      12696046., 12745172., 12794298., 12843424., 12812690., 12862300.,
      12911910., 12961520., 3364526.,  3374932.,  3385338.,  3395744.,
      3481170.,  3492060.,  3502950.,  3513840.,  5230830.,  5248980.,
      5267130.,  5285280.,  5347474.,  5366108.,  5384742.,  5403376.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x16x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2905088.,  4070176.,  4287712.,  2733472.,  5636136.,  7755737.,
      7990961.,  5022325.,  8440872.,  11519321., 11754545., 7338485.,
      3856552.,  5184025.,  5279505.,  3227189.,  2905088.,  4070176.,
      4287712.,  2733472.,  5636136.,  7755737.,  7990961.,  5022325.,
      8440872.,  11519321., 11754545., 7338485.,  3856552.,  5184025.,
      5279505.,  3227189.,  2905088.,  4070176.,  4287712.,  2733472.,
      5636136.,  7755737.,  7990961.,  5022325.,  8440872.,  11519321.,
      11754545., 7338485.,  3856552.,  5184025.,  5279505.,  3227189.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x16x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6756035.,  6991259.,  10519619., 10754843., 6756035.,  6991259.,
      10519619., 10754843., 6756035.,  6991259.,  10519619., 10754843.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x16x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2263488., 2278912., 3143928., 3166016., 3344120., 3367616., 2127384.,
      2142784., 2561144., 2580048., 3597935., 3625138., 3832975., 3862114.,
      2500883., 2520042., 3003512., 3028560., 4106351., 4142002., 4341391.,
      4378978., 2698003., 2722538., 1917848., 1933136., 2678291., 2700082.,
      2814771., 2837794., 1857191., 1872234., 2263488., 2278912., 3143928.,
      3166016., 3344120., 3367616., 2127384., 2142784., 2561144., 2580048.,
      3597935., 3625138., 3832975., 3862114., 2500883., 2520042., 3003512.,
      3028560., 4106351., 4142002., 4341391., 4378978., 2698003., 2722538.,
      1917848., 1933136., 2678291., 2700082., 2814771., 2837794., 1857191.,
      1872234., 2263488., 2278912., 3143928., 3166016., 3344120., 3367616.,
      2127384., 2142784., 2561144., 2580048., 3597935., 3625138., 3832975.,
      3862114., 2500883., 2520042., 3003512., 3028560., 4106351., 4142002.,
      4341391., 4378978., 2698003., 2722538., 1917848., 1933136., 2678291.,
      2700082., 2814771., 2837794., 1857191., 1872234.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x16x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3015783., 3040390., 3250823., 3277366., 3974759., 4007814.,
      4209799., 4244790., 3015783., 3040390., 3250823., 3277366.,
      3974759., 4007814., 4209799., 4244790., 3015783., 3040390.,
      3250823., 3277366., 3974759., 4007814., 4209799., 4244790.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x16x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2054208., 2069632., 2085056., 2100480., 2811816., 2833904., 2855992.,
      2878080., 2981416., 3004912., 3028408., 3051904., 1947400., 1962800.,
      1978200., 1993600., 2392344., 2411248., 2430152., 2449056., 3260315.,
      3287518., 3314721., 3341924., 3494987., 3524126., 3553265., 3582404.,
      2231887., 2251046., 2270205., 2289364., 3402008., 3427056., 3452104.,
      3477152., 4596379., 4632030., 4667681., 4703332., 4831051., 4868638.,
      4906225., 4943812., 3079503., 3104038., 3128573., 3153108., 1904248.,
      1919536., 1934824., 1950112., 2561799., 2583590., 2605381., 2627172.,
      2702455., 2725478., 2748501., 2771524., 1704843., 1719886., 1734929.,
      1749972., 2054208., 2069632., 2085056., 2100480., 2811816., 2833904.,
      2855992., 2878080., 2981416., 3004912., 3028408., 3051904., 1947400.,
      1962800., 1978200., 1993600., 2392344., 2411248., 2430152., 2449056.,
      3260315., 3287518., 3314721., 3341924., 3494987., 3524126., 3553265.,
      3582404., 2231887., 2251046., 2270205., 2289364., 3402008., 3427056.,
      3452104., 3477152., 4596379., 4632030., 4667681., 4703332., 4831051.,
      4868638., 4906225., 4943812., 3079503., 3104038., 3128573., 3153108.,
      1904248., 1919536., 1934824., 1950112., 2561799., 2583590., 2605381.,
      2627172., 2702455., 2725478., 2748501., 2771524., 1704843., 1719886.,
      1734929., 1749972., 2054208., 2069632., 2085056., 2100480., 2811816.,
      2833904., 2855992., 2878080., 2981416., 3004912., 3028408., 3051904.,
      1947400., 1962800., 1978200., 1993600., 2392344., 2411248., 2430152.,
      2449056., 3260315., 3287518., 3314721., 3341924., 3494987., 3524126.,
      3553265., 3582404., 2231887., 2251046., 2270205., 2289364., 3402008.,
      3427056., 3452104., 3477152., 4596379., 4632030., 4667681., 4703332.,
      4831051., 4868638., 4906225., 4943812., 3079503., 3104038., 3128573.,
      3153108., 1904248., 1919536., 1934824., 1950112., 2561799., 2583590.,
      2605381., 2627172., 2702455., 2725478., 2748501., 2771524., 1704843.,
      1719886., 1734929., 1749972.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x16x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3090863., 3115470., 3140077., 3164684., 3325535., 3352078., 3378621.,
      3405164., 3886255., 3919310., 3952365., 3985420., 4120927., 4155918.,
      4190909., 4225900., 3090863., 3115470., 3140077., 3164684., 3325535.,
      3352078., 3378621., 3405164., 3886255., 3919310., 3952365., 3985420.,
      4120927., 4155918., 4190909., 4225900., 3090863., 3115470., 3140077.,
      3164684., 3325535., 3352078., 3378621., 3405164., 3886255., 3919310.,
      3952365., 3985420., 4120927., 4155918., 4190909., 4225900.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x16x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4265600., 6264496., 7068080., 4725616., 5459728., 7889790., 8833822.,
      5765942., 5459728., 7889790., 8833822., 5765942., 2888656., 4212710.,
      4761094., 3190334., 4265600., 6264496., 7068080., 4725616., 5459728.,
      7889790., 8833822., 5765942., 5459728., 7889790., 8833822., 5765942.,
      2888656., 4212710., 4761094., 3190334., 4265600., 6264496., 7068080.,
      4725616., 5459728., 7889790., 8833822., 5765942., 5459728., 7889790.,
      8833822., 5765942., 2888656., 4212710., 4761094., 3190334.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x16x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6457110., 7401142., 6457110., 7401142., 6457110., 7401142.,
      6457110., 7401142., 6457110., 7401142., 6457110., 7401142.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x16x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3674752., 3703552., 5252336., 5295456., 5936368., 5985120., 3938480.,
      3971296., 5821296., 5863968., 8238306., 8301820., 9184738., 9255996.,
      6004138., 6051948., 5821296., 5863968., 8238306., 8301820., 9184738.,
      9255996., 6004138., 6051948., 3863344., 3891616., 5434346., 5476300.,
      6001898., 6048780., 3887058., 3918460., 3674752., 3703552., 5252336.,
      5295456., 5936368., 5985120., 3938480., 3971296., 5821296., 5863968.,
      8238306., 8301820., 9184738., 9255996., 6004138., 6051948., 5821296.,
      5863968., 8238306., 8301820., 9184738., 9255996., 6004138., 6051948.,
      3863344., 3891616., 5434346., 5476300., 6001898., 6048780., 3887058.,
      3918460., 3674752., 3703552., 5252336., 5295456., 5936368., 5985120.,
      3938480., 3971296., 5821296., 5863968., 8238306., 8301820., 9184738.,
      9255996., 6004138., 6051948., 5821296., 5863968., 8238306., 8301820.,
      9184738., 9255996., 6004138., 6051948., 3863344., 3891616., 5434346.,
      5476300., 6001898., 6048780., 3887058., 3918460.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x16x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6468770., 6521900., 7415202., 7476076., 6468770., 6521900.,
      7415202., 7476076., 6468770., 6521900., 7415202., 7476076.,
      6468770., 6521900., 7415202., 7476076., 6468770., 6521900.,
      7415202., 7476076., 6468770., 6521900., 7415202., 7476076.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x16x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3641472., 3670272., 3699072., 3727872., 5359472., 5402592., 5445712.,
      5488832., 6050160., 6098912., 6147664., 6196416., 3874096., 3906912.,
      3939728., 3972544., 5528112., 5570784., 5613456., 5656128., 8083370.,
      8146884., 8210398., 8273912., 9034602., 9105860., 9177118., 9248376.,
      5866130., 5913940., 5961750., 6009560., 5528112., 5570784., 5613456.,
      5656128., 8083370., 8146884., 8210398., 8273912., 9034602., 9105860.,
      9177118., 9248376., 5866130., 5913940., 5961750., 6009560., 3851248.,
      3879520., 3907792., 3936064., 5506034., 5547988., 5589942., 5631896.,
      6111922., 6158804., 6205686., 6252568., 3962618., 3994020., 4025422.,
      4056824., 3641472., 3670272., 3699072., 3727872., 5359472., 5402592.,
      5445712., 5488832., 6050160., 6098912., 6147664., 6196416., 3874096.,
      3906912., 3939728., 3972544., 5528112., 5570784., 5613456., 5656128.,
      8083370., 8146884., 8210398., 8273912., 9034602., 9105860., 9177118.,
      9248376., 5866130., 5913940., 5961750., 6009560., 5528112., 5570784.,
      5613456., 5656128., 8083370., 8146884., 8210398., 8273912., 9034602.,
      9105860., 9177118., 9248376., 5866130., 5913940., 5961750., 6009560.,
      3851248., 3879520., 3907792., 3936064., 5506034., 5547988., 5589942.,
      5631896., 6111922., 6158804., 6205686., 6252568., 3962618., 3994020.,
      4025422., 4056824., 3641472., 3670272., 3699072., 3727872., 5359472.,
      5402592., 5445712., 5488832., 6050160., 6098912., 6147664., 6196416.,
      3874096., 3906912., 3939728., 3972544., 5528112., 5570784., 5613456.,
      5656128., 8083370., 8146884., 8210398., 8273912., 9034602., 9105860.,
      9177118., 9248376., 5866130., 5913940., 5961750., 6009560., 5528112.,
      5570784., 5613456., 5656128., 8083370., 8146884., 8210398., 8273912.,
      9034602., 9105860., 9177118., 9248376., 5866130., 5913940., 5961750.,
      6009560., 3851248., 3879520., 3907792., 3936064., 5506034., 5547988.,
      5589942., 5631896., 6111922., 6158804., 6205686., 6252568., 3962618.,
      3994020., 4025422., 4056824.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x16x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6426554., 6479684., 6532814., 6585944., 7377786., 7438660., 7499534.,
      7560408., 6426554., 6479684., 6532814., 6585944., 7377786., 7438660.,
      7499534., 7560408., 6426554., 6479684., 6532814., 6585944., 7377786.,
      7438660., 7499534., 7560408., 6426554., 6479684., 6532814., 6585944.,
      7377786., 7438660., 7499534., 7560408., 6426554., 6479684., 6532814.,
      6585944., 7377786., 7438660., 7499534., 7560408., 6426554., 6479684.,
      6532814., 6585944., 7377786., 7438660., 7499534., 7560408.};
  const std::array<int, 4> in_shape = {{3, 16, 16, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x18x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      356720.,  562936.,  590216.,  555060.,  332636.,  696080.,  1082224.,
      1111748., 1027290., 607706.,  1045352., 1613656., 1643180., 1506450.,
      885698.,  480984.,  728420.,  740432.,  674520.,  388276.,  1638896.,
      2527096., 2554376., 2329140., 1369436., 2093168., 3207952., 3237476.,
      2943930., 1719674., 2442440., 3739384., 3768908., 3423090., 1997666.,
      1059576., 1593284., 1605296., 1450680., 829780.,  2921072., 4491256.,
      4518536., 4103220., 2406236., 3490256., 5333680., 5363204., 4860570.,
      2831642., 3839528., 5865112., 5894636., 5339730., 3109634., 1638168.,
      2458148., 2470160., 2226840., 1271284.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x18x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      949366.,  978890.,  1480798., 1510322., 3075094., 3104618.,
      3606526., 3636050., 5200822., 5230346., 5732254., 5761778.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x18x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      709688.,   713440.,   1119800.,  1125872.,  1174008.,  1180432.,
      1104000.,  1110120.,  661504.,   665272.,   1383536.,  1392160.,
      2150654.,  2164448.,  2209218.,  2223496.,  2041215.,  2054580.,
      1207261.,  1215412.,  2076536.,  2090704.,  3204806.,  3227312.,
      3263370.,  3286360.,  2991615.,  3012900.,  1758493.,  1771396.,
      951188.,   961968.,   1439746.,  1456840.,  1463462.,  1480864.,
      1332975.,  1349040.,  766829.,   776552.,   3257912.,  3277792.,
      5022776.,  5054192.,  5076984.,  5108752.,  4629120.,  4658280.,
      2721280.,  2738872.,  4155536.,  4186336.,  6367262.,  6415904.,
      6425826.,  6474952.,  5842815.,  5887860.,  3412189.,  3439348.,
      4848536.,  4884880.,  7421414.,  7478768.,  7479978.,  7537816.,
      6793215.,  6846180.,  3963421.,  3995332.,  2094260.,  2119152.,
      3147298.,  3186568.,  3171014.,  3210592.,  2865135.,  2901360.,
      1637741.,  1659560.,  5806136.,  5842144.,  8925752.,  8982512.,
      8979960.,  9037072.,  8154240.,  8206440.,  4781056.,  4812472.,
      6927536.,  6980512.,  10583870., 10667360., 10642434., 10726408.,
      9644415.,  9721140.,  5617117.,  5663284.,  7620536.,  7679056.,
      11638022., 11730224., 11696586., 11789272., 10594815., 10679460.,
      6168349.,  6219268.,  3237332.,  3276336.,  4854850.,  4916296.,
      4878566.,  4940320.,  4397295.,  4453680.,  2508653.,  2542568.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x18x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1887116.,  1898732.,  1945680.,  1957780.,  2941268.,  2961596.,
      2999832.,  3020644.,  6103724.,  6150188.,  6162288.,  6209236.,
      7157876.,  7213052.,  7216440.,  7272100.,  10320332., 10401644.,
      10378896., 10460692., 11374484., 11464508., 11433048., 11523556.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x18x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1415624.,  1419376.,  1423128.,  1426880.,  2233528.,  2239600.,
      2245672.,  2251744.,  2341592.,  2348016.,  2354440.,  2360864.,
      2201880.,  2208000.,  2214120.,  2220240.,  1319240.,  1323008.,
      1326776.,  1330544.,  2758448.,  2767072.,  2775696.,  2784320.,
      4287514.,  4301308.,  4315102.,  4328896.,  4404158.,  4418436.,
      4432714.,  4446992.,  4069065.,  4082430.,  4095795.,  4109160.,
      2406371.,  2414522.,  2422673.,  2430824.,  4138904.,  4153072.,
      4167240.,  4181408.,  6387106.,  6409612.,  6432118.,  6454624.,
      6503750.,  6526740.,  6549730.,  6572720.,  5961945.,  5983230.,
      6004515.,  6025800.,  3504083.,  3516986.,  3529889.,  3542792.,
      1891596.,  1902376.,  1913156.,  1923936.,  2862398.,  2879492.,
      2896586.,  2913680.,  2909522.,  2926924.,  2944326.,  2961728.,
      2649885.,  2665950.,  2682015.,  2698080.,  1523935.,  1533658.,
      1543381.,  1553104.,  6495944.,  6515824.,  6535704.,  6555584.,
      10014136., 10045552., 10076968., 10108384., 10122200., 10153968.,
      10185736., 10217504., 9229080.,  9258240.,  9287400.,  9316560.,
      5424968.,  5442560.,  5460152.,  5477744.,  8280272.,  8311072.,
      8341872.,  8372672.,  12685882., 12734524., 12783166., 12831808.,
      12802526., 12851652., 12900778., 12949904., 11640585., 11685630.,
      11730675., 11775720., 6797219.,  6824378.,  6851537.,  6878696.,
      5091128.,  5116720.,  5142312.,  5167904.,  7209922.,  7248844.,
      7287766.,  7326688.,  6648678.,  6686036.,  6723394.,  6760752.,
      5484825.,  5517310.,  5549795.,  5582280.,  3164051.,  3183674.,
      3203297.,  3222920.,  1486380.,  1500520.,  1514660.,  1528800.,
      1923806.,  1944644.,  1965482.,  1986320.,  1653490.,  1672588.,
      1691686.,  1710784.,  1249885.,  1265630.,  1281375.,  1297120.,
      685471.,   695002.,   704533.,   714064.,   2544584.,  2551920.,
      2559256.,  2566592.,  3962552.,  3974256.,  3985960.,  3997664.,
      4070616.,  4082672.,  4094728.,  4106784.,  3763480.,  3774720.,
      3785960.,  3797200.,  2231624.,  2238464.,  2245304.,  2252144.,
      3985520.,  3999072.,  4012624.,  4026176.,  6153818.,  6175356.,
      6196894.,  6218432.,  6270462.,  6292484.,  6314506.,  6336528.,
      5751625.,  5772030.,  5792435.,  5812840.,  3382115.,  3394490.,
      3406865.,  3419240.,  5365976.,  5385072.,  5404168.,  5423264.,
      8253410.,  8283660.,  8313910.,  8344160.,  8370054.,  8400788.,
      8431522.,  8462256.,  7644505.,  7672830.,  7701155.,  7729480.,
      4479827.,  4496954.,  4514081.,  4531208.,  2396492.,  2410408.,
      2424324.,  2438240.,  3616382.,  3638404.,  3660426.,  3682448.,
      3663506.,  3685836.,  3708166.,  3730496.,  3326365.,  3346910.,
      3367455.,  3388000.,  1908319.,  1920730.,  1933141.,  1945552.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x18x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3762616.,  3774232.,  3785848.,  3797464.,  3879260.,  3891360.,
      3903460.,  3915560.,  5862208.,  5882536.,  5902864.,  5923192.,
      5978852.,  5999664.,  6020476.,  6041288.,  12160984., 12207448.,
      12253912., 12300376., 12277628., 12324576., 12371524., 12418472.,
      8718176.,  8760552.,  8802928.,  8845304.,  8066820.,  8107632.,
      8148444.,  8189256.,  5628920.,  5648280.,  5667640.,  5687000.,
      5745564.,  5765408.,  5785252.,  5805096.,  7728512.,  7756584.,
      7784656.,  7812728.,  7845156.,  7873712.,  7902268.,  7930824.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x18x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2837408., 4477792., 4695328., 4416000., 2646400., 5541767.,  8615563.,
      8850787., 8178390., 4837690., 5968631., 8711611., 8117395.,  7500470.,
      4404058., 2367239., 3271275., 2897763., 2665590., 1517018.,  3973536.,
      6218080., 6435616., 5987840., 3564928., 6778695., 10497355., 10732579.,
      9875030., 5821882., 4970679., 7118971., 6672211., 5602870.,  3280858.,
      1634759., 2182699., 1956643., 1559030., 880730.,  5109664.,  7958368.,
      8175904., 7559680., 4483456., 6327559., 9771531., 9338595.,  7905750.,
      4158010., 3935351., 6053179., 5890579., 5075382., 2698330.,  1135239.,
      1711083., 1679075., 1462134., 785114.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x18x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7557055., 7792279., 10103023., 9418695.,  9438847., 9674071.,
      8104879., 7568007., 11320639., 10820119., 6611055., 6380871.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x18x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1655256., 1667648., 2476344., 2495936., 2484024., 2504000., 2421680.,
      2440960., 1442384., 1454336., 2645403., 2662926., 4175623., 4203542.,
      4398375., 4427206., 4232262., 4260012., 2538842., 2556020., 2127323.,
      2147566., 3016007., 3047030., 2853735., 2883622., 2779206., 2807916.,
      1627994., 1645748., 1955535., 1968398., 2692875., 2712534., 2362411.,
      2381254., 2229550., 2247660., 1291762., 1302964., 1819096., 1833536.,
      2640184., 2661824., 2611000., 2632000., 2470832., 2490112., 1491536.,
      1503488., 3122843., 3145102., 4405255., 4439446., 4247079., 4281158.,
      3839046., 3870636., 2225498., 2244980., 2194139., 2213486., 3237447.,
      3265526., 3284071., 3309990., 3094598., 3116908., 1867610., 1881524.,
      1438671., 1452174., 1941515., 1961814., 1758507., 1777990., 1449262.,
      1466092., 849394.,  859828.,  2196952., 2211904., 3467576., 3491264.,
      3585848., 3608896., 3433392., 3453696., 2081360., 2093312., 2400155.,
      2422030., 3613959., 3648790., 3329831., 3363014., 2749510., 2777772.,
      1383770., 1399412., 2929627., 2948590., 4633415., 4664182., 4734311.,
      4765478., 4028486., 4056684., 2070362., 2086580., 1156303., 1168910.,
      1807627., 1828054., 1818155., 1838278., 1676590., 1694188., 947698.,
      957364.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x18x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3331959., 3356798., 3509655., 3535406., 3625399., 3658974.,
      3327959., 3360398., 4597879., 4628990., 4349591., 4380590.,
      3035831., 3066462., 2902231., 2930702., 4561271., 4598654.,
      4119447., 4155182., 3744695., 3772382., 3909079., 3937166.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x18x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1547080., 1559472., 1571864., 1584256., 2333160., 2352752., 2372344.,
      2391936., 2380904., 2400880., 2420856., 2440832., 2342672., 2361952.,
      2381232., 2400512., 1421296., 1433248., 1445200., 1457152., 2378691.,
      2396214., 2413737., 2431260., 3625471., 3653390., 3681309., 3709228.,
      3836591., 3865422., 3894253., 3923084., 3768102., 3795852., 3823602.,
      3851352., 2183578., 2200756., 2217934., 2235112., 2544035., 2564278.,
      2584521., 2604764., 3654239., 3685262., 3716285., 3747308., 3621647.,
      3651534., 3681421., 3711308., 3523430., 3552140., 3580850., 3609560.,
      2081626., 2099380., 2117134., 2134888., 1857375., 1870238., 1883101.,
      1895964., 2437451., 2457110., 2476769., 2496428., 2170555., 2189398.,
      2208241., 2227084., 2102430., 2120540., 2138650., 2156760., 1123874.,
      1135076., 1146278., 1157480., 2003784., 2018224., 2032664., 2047104.,
      2920936., 2942576., 2964216., 2985856., 2633832., 2654832., 2675832.,
      2696832., 2342672., 2361952., 2381232., 2400512., 1322992., 1334944.,
      1346896., 1358848., 2902851., 2925110., 2947369., 2969628., 4045695.,
      4079886., 4114077., 4148268., 4020271., 4054350., 4088429., 4122508.,
      3797030., 3828620., 3860210., 3891800., 2144410., 2163892., 2183374.,
      2202856., 2383651., 2402998., 2422345., 2441692., 3149791., 3177870.,
      3205949., 3234028., 3011727., 3037646., 3063565., 3089484., 2751590.,
      2773900., 2796210., 2818520., 1581658., 1595572., 1609486., 1623400.,
      1609439., 1622942., 1636445., 1649948., 2244811., 2265110., 2285409.,
      2305708., 2272827., 2292310., 2311793., 2331276., 2214302., 2231132.,
      2247962., 2264792., 1222946., 1233380., 1243814., 1254248., 1841480.,
      1856432., 1871384., 1886336., 2738664., 2762352., 2786040., 2809728.,
      2746472., 2769520., 2792568., 2815616., 2595600., 2615904., 2636208.,
      2656512., 1519600., 1531552., 1543504., 1555456., 2866883., 2888758.,
      2910633., 2932508., 4395775., 4430606., 4465437., 4500268., 3988911.,
      4022094., 4055277., 4088460., 3357990., 3386252., 3414514., 3442776.,
      1841050., 1856692., 1872334., 1887976., 2642595., 2661558., 2680521.,
      2699484., 4071263., 4102030., 4132797., 4163564., 4170255., 4201422.,
      4232589., 4263756., 3597670., 3625868., 3654066., 3682264., 1788250.,
      1804468., 1820686., 1836904., 1438815., 1451422., 1464029., 1476636.,
      2107979., 2128406., 2148833., 2169260., 1998267., 2018390., 2038513.,
      2058636., 1717918., 1735516., 1753114., 1770712., 830498.,  840164.,
      849830.,  859496.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x18x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2991847., 3016686., 3041525., 3066364., 3112855., 3138606., 3164357.,
      3190108., 4086087., 4119662., 4153237., 4186812., 4045303., 4077742.,
      4110181., 4142620., 4042855., 4073966., 4105077., 4136188., 3837207.,
      3868206., 3899205., 3930204., 3794631., 3825262., 3855893., 3886524.,
      3296119., 3324590., 3353061., 3381532., 4454887., 4492270., 4529653.,
      4567036., 4256919., 4292654., 4328389., 4364124., 3347527., 3375214.,
      3402901., 3430588., 3442423., 3470510., 3498597., 3526684.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x18x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3490288., 5477424., 5729072., 5857312., 3654368., 5084910., 8060278.,
      7936790., 7132580., 3938300., 5107502., 7778998., 7655510., 6785316.,
      3490940., 3340726., 4636958., 3995966., 3808532., 2169868., 4385264.,
      6522416., 6641456., 5810208., 3237600., 5045230., 7276662., 7388694.,
      6814628., 4046332., 5001774., 7551926., 8115030., 7546660., 4458108.,
      3003574., 4325918., 4233278., 3833620., 2368012., 3490288., 5477424.,
      5729072., 5857312., 3654368., 5084910., 8060278., 7936790., 7132580.,
      3938300., 5107502., 7778998., 7655510., 6785316., 3490940., 3340726.,
      4636958., 3995966., 3808532., 2169868.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x18x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8267046., 7738054., 7219814., 6952966., 7618598., 7505350.,
      7263078., 7465734., 8267046., 7738054., 7219814., 6952966.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x18x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3114672., 3140576., 4736752., 4778080., 4847344., 4888160., 4922784.,
      4960832., 3067744., 3090880., 5386922., 5426140., 8567202., 8630508.,
      8174242., 8236076., 7357580., 7413064., 4216852., 4248568., 5268650.,
      5307484., 7973794., 8035180., 8105122., 8165036., 7349388., 7406664.,
      3909652., 3943672., 3483346., 3509100., 4613034., 4653628., 3857578.,
      3895932., 3485116., 3520552., 1680740., 1700888., 4114096., 4144096.,
      6035184., 6081632., 5617392., 5664352., 4693408., 4735552., 2494304.,
      2519488., 4913834., 4953564., 6869410., 6932204., 7205538., 7270956.,
      6587532., 6646088., 3643412., 3678200., 5184682., 5227100., 7123874.,
      7187820., 7316642., 7380140., 6907020., 6963272., 4007956., 4043000.,
      3071698., 3096940., 4516778., 4555836., 4854954., 4894844., 4976060.,
      5012520., 2860388., 2883608., 3114672., 3140576., 4736752., 4778080.,
      4847344., 4888160., 4922784., 4960832., 3067744., 3090880., 5386922.,
      5426140., 8567202., 8630508., 8174242., 8236076., 7357580., 7413064.,
      4216852., 4248568., 5268650., 5307484., 7973794., 8035180., 8105122.,
      8165036., 7349388., 7406664., 3909652., 3943672., 3483346., 3509100.,
      4613034., 4653628., 3857578., 3895932., 3485116., 3520552., 1680740.,
      1700888.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x18x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7417122., 7479372., 7261730., 7322508., 7388962., 7449292.,
      7495714., 7554572., 8086818., 8148556., 7972386., 8036748.,
      7866146., 7929036., 7338018., 7400460., 7417122., 7479372.,
      7261730., 7322508., 7388962., 7449292., 7495714., 7554572.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x16x18x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3427376., 3453280., 3479184., 3505088., 5546608., 5587936., 5629264.,
      5670592., 5096560., 5137376., 5178192., 5219008., 4905632., 4943680.,
      4981728., 5019776., 3023456., 3046592., 3069728., 3092864., 5109794.,
      5149012., 5188230., 5227448., 8335866., 8399172., 8462478., 8525784.,
      7666106., 7727940., 7789774., 7851608., 6803036., 6858520., 6914004.,
      6969488., 4279364., 4311080., 4342796., 4374512., 4545954., 4584788.,
      4623622., 4662456., 7380346., 7441732., 7503118., 7564504., 7497018.,
      7556932., 7616846., 7676760., 6883164., 6940440., 6997716., 7054992.,
      4318020., 4352040., 4386060., 4420080., 3008778., 3034532., 3060286.,
      3086040., 4757698., 4798292., 4838886., 4879480., 4559746., 4598100.,
      4636454., 4674808., 4355340., 4390776., 4426212., 4461648., 2041364.,
      2061512., 2081660., 2101808., 3324976., 3354976., 3384976., 3414976.,
      5647984., 5694432., 5740880., 5787328., 5450864., 5497824., 5544784.,
      5591744., 4967072., 5009216., 5051360., 5093504., 2792032., 2817216.,
      2842400., 2867584., 4425250., 4464980., 4504710., 4544440., 7431162.,
      7493956., 7556750., 7619544., 7691194., 7756612., 7822030., 7887448.,
      6701660., 6760216., 6818772., 6877328., 3915844., 3950632., 3985420.,
      4020208., 5160866., 5203284., 5245702., 5288120., 7381882., 7445828.,
      7509774., 7573720., 7882554., 7946052., 8009550., 8073048., 6916956.,
      6973208., 7029460., 7085712., 3989316., 4024360., 4059404., 4094448.,
      3496714., 3521956., 3547198., 3572440., 4828866., 4867924., 4906982.,
      4946040., 4980098., 5019988., 5059878., 5099768., 4976908., 5013368.,
      5049828., 5086288., 2955796., 2979016., 3002236., 3025456., 3427376.,
      3453280., 3479184., 3505088., 5546608., 5587936., 5629264., 5670592.,
      5096560., 5137376., 5178192., 5219008., 4905632., 4943680., 4981728.,
      5019776., 3023456., 3046592., 3069728., 3092864., 5109794., 5149012.,
      5188230., 5227448., 8335866., 8399172., 8462478., 8525784., 7666106.,
      7727940., 7789774., 7851608., 6803036., 6858520., 6914004., 6969488.,
      4279364., 4311080., 4342796., 4374512., 4545954., 4584788., 4623622.,
      4662456., 7380346., 7441732., 7503118., 7564504., 7497018., 7556932.,
      7616846., 7676760., 6883164., 6940440., 6997716., 7054992., 4318020.,
      4352040., 4386060., 4420080., 3008778., 3034532., 3060286., 3086040.,
      4757698., 4798292., 4838886., 4879480., 4559746., 4598100., 4636454.,
      4674808., 4355340., 4390776., 4426212., 4461648., 2041364., 2061512.,
      2081660., 2101808.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x16x18x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7879962., 7942212., 8004462., 8066712., 7423194., 7483972., 7544750.,
      7605528., 7792794., 7853124., 7913454., 7973784., 7598170., 7657028.,
      7715886., 7774744., 7515930., 7577668., 7639406., 7701144., 7661274.,
      7725636., 7789998., 7854360., 8089242., 8152132., 8215022., 8277912.,
      7410266., 7472708., 7535150., 7597592., 7879962., 7942212., 8004462.,
      8066712., 7423194., 7483972., 7544750., 7605528., 7792794., 7853124.,
      7913454., 7973784., 7598170., 7657028., 7715886., 7774744.};
  const std::array<int, 4> in_shape = {{3, 16, 18, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x15x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      236621.,  377531.,  403095.,  258769.,  510587.,  798721.,  828245.,
      522599.,  801647.,  1241581., 1271105., 795179.,  866355.,  1332155.,
      1356575., 842695.,  350637.,  526581.,  535425.,  324009.,  1361171.,
      2103101., 2128665., 1330399., 1820357., 2791591., 2821115., 1749209.,
      2111417., 3234451., 3263975., 2021789., 1953105., 2980505., 3004925.,
      1853845., 753207.,  1123551., 1132395., 681219.,  2485721., 3828671.,
      3854235., 2402029., 3130127., 4784461., 4813985., 2975819., 3421187.,
      5227321., 5256845., 3248399., 3039855., 4628855., 4653275., 2864995.,
      1155777., 1720521., 1729365., 1038429.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x15x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      798721.,  828245.,  1241581., 1271105., 2791591., 2821115.,
      3234451., 3263975., 4784461., 4813985., 5227321., 5256845.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x15x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      470841.,   473242.,   751135.,   755062.,   801955.,  806190.,  514745.,
      517538.,   1015091.,  1021174.,  1587641.,  1597442., 1646205., 1656490.,
      1038499.,  1045198.,  1592591.,  1603294.,  2466101., 2483162., 2524665.,
      2542210.,  1579039.,  1590358.,  1719305.,  1732710., 2643025., 2664310.,
      2691425.,  2713150.,  1671425.,  1685390.,  691971.,  701274.,  1038411.,
      1053162.,  1055835.,  1070850.,  638379.,   648018.,  2706711., 2722342.,
      4181485.,  4206202.,  4232305.,  4257330.,  2644775., 2660798., 3613841.,
      3640714.,  5540711.,  5583182.,  5599275.,  5642230., 3470929., 3498418.,
      4191341.,  4222834.,  6419171.,  6468902.,  6477735., 6527950., 4011469.,
      4043578.,  3873905.,  3906210.,  5910025.,  5961010., 5958425., 6009850.,
      3674825.,  3707690.,  1485771.,  1506414.,  2214531., 2247102., 2231955.,
      2264790.,  1341459.,  1362438.,  4942581.,  4971442., 7611835., 7657342.,
      7662655.,  7708470.,  4774805.,  4804058.,  6212591., 6260254., 9493781.,
      9568922.,  9552345.,  9627970.,  5903359.,  5951638., 6790091., 6842374.,
      10372241., 10454642., 10430805., 10513690., 6443899., 6496798., 6028505.,
      6079710.,  9177025.,  9257710.,  9225425.,  9306550., 5678225., 5729990.,
      2279571.,  2311554.,  3390651.,  3441042.,  3408075., 3458730., 2044539.,
      2076858.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x15x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1587641., 1597442., 1646205.,  1656490.,  2466101.,  2483162.,
      2524665., 2542210., 5540711.,  5583182.,  5599275.,  5642230.,
      6419171., 6468902., 6477735.,  6527950.,  9493781.,  9568922.,
      9552345., 9627970., 10372241., 10454642., 10430805., 10513690.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x15x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      939281.,   941682.,   944083.,   946484.,   1498343.,  1502270.,
      1506197.,  1510124.,  1599675.,  1603910.,  1608145.,  1612380.,
      1026697.,  1029490.,  1032283.,  1035076.,  2024099.,  2030182.,
      2036265.,  2042348.,  3165481.,  3175282.,  3185083.,  3194884.,
      3282125.,  3292410.,  3302695.,  3312980.,  2070299.,  2076998.,
      2083697.,  2090396.,  3174479.,  3185182.,  3195885.,  3206588.,
      4915141.,  4932202.,  4949263.,  4966324.,  5031785.,  5049330.,
      5066875.,  5084420.,  3146759.,  3158078.,  3169397.,  3180716.,
      3425205.,  3438610.,  3452015.,  3465420.,  5264765.,  5286050.,
      5307335.,  5328620.,  5361125.,  5382850.,  5404575.,  5426300.,
      3328885.,  3342850.,  3356815.,  3370780.,  1374639.,  1383942.,
      1393245.,  1402548.,  2062071.,  2076822.,  2091573.,  2106324.,
      2096655.,  2111670.,  2126685.,  2141700.,  1267119.,  1276758.,
      1286397.,  1296036.,  5397791.,  5413422.,  5429053.,  5444684.,
      8338253.,  8362970.,  8387687.,  8412404.,  8439585.,  8464610.,
      8489635.,  8514660.,  5273527.,  5289550.,  5305573.,  5321596.,
      7200809.,  7227682.,  7254555.,  7281428.,  11038951., 11081422.,
      11123893., 11166364., 11155595., 11198550., 11241505., 11284460.,
      6914369.,  6941858.,  6969347.,  6996836.,  8351189.,  8382682.,
      8414175.,  8445668.,  12788611., 12838342., 12888073., 12937804.,
      12905255., 12955470., 13005685., 13055900., 7990829.,  8022938.,
      8055047.,  8087156.,  5206705.,  5232866.,  5259027.,  5285188.,
      7683305.,  7724050.,  7764795.,  7805540.,  7416145.,  7456306.,
      7496467.,  7536628.,  4542769.,  4568466.,  4594163.,  4619860.,
      1523443.,  1537942.,  1552441.,  1566940.,  2112971.,  2135302.,
      2157633.,  2179964.,  1964259.,  1985830.,  2007401.,  2028972.,
      1149491.,  1163302.,  1177113.,  1190924.,  1401645.,  1405418.,
      1409191.,  1412964.,  2207667.,  2213750.,  2219833.,  2225916.,
      2308999.,  2315390.,  2321781.,  2328172.,  1467109.,  1471274.,
      1475439.,  1479604.,  2560943.,  2569182.,  2577421.,  2585660.,
      3981989.,  3995178.,  4008367.,  4021556.,  4098633.,  4112306.,
      4125979.,  4139652.,  2572647.,  2581502.,  2590357.,  2599212.,
      3711323.,  3724182.,  3737041.,  3749900.,  5731649.,  5752098.,
      5772547.,  5792996.,  5848293.,  5869226.,  5890159.,  5911092.,
      3649107.,  3662582.,  3676057.,  3689532.,  3870125.,  3885490.,
      3900855.,  3916220.,  5939285.,  5963650.,  5988015.,  6012380.,
      6035645.,  6060450.,  6085255.,  6110060.,  3742445.,  3758370.,
      3774295.,  3790220.,  1538103.,  1548582.,  1559061.,  1569540.,
      2304159.,  2320758.,  2337357.,  2353956.,  2338743.,  2355606.,
      2372469.,  2389332.,  1411767.,  1422582.,  1433397.,  1444212.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x15x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3165481.,  3175282.,  3185083.,  3194884.,  3282125.,  3292410.,
      3302695.,  3312980.,  4915141.,  4932202.,  4949263.,  4966324.,
      5031785.,  5049330.,  5066875.,  5084420.,  11038951., 11081422.,
      11123893., 11166364., 11155595., 11198550., 11241505., 11284460.,
      12788611., 12838342., 12888073., 12937804., 12905255., 12955470.,
      13005685., 13055900., 3981989.,  3995178.,  4008367.,  4021556.,
      4098633.,  4112306.,  4125979.,  4139652.,  5731649.,  5752098.,
      5772547.,  5792996.,  5848293.,  5869226.,  5890159.,  5911092.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x15x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1879885.,  2999689.,  3203585.,  2056677.,  4062905., 6355525., 6590749.,
      4158385.,  6382145.,  9883885.,  10119109., 6329785., 5578162., 8447050.,
      8437242.,  5233186.,  2006334.,  2924390.,  2880438., 1727950., 2344993.,
      3713325.,  3917221.,  2499833.,  4604061.,  7178809., 7414033., 4665045.,
      6923301.,  10707169., 10942393., 6836445.,  4823802., 7177010., 7005922.,
      4335338.,  1509622.,  2120574.,  2005454.,  1190406., 2810101., 4426961.,
      4630857.,  2942989.,  5145217.,  8002093.,  8237317., 5171705., 7464457.,
      11530453., 11765677., 7343105.,  4184130.,  6111770., 5822410., 3595186.,
      1127598.,  1521558.,  1378278.,  810558.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x15x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6355525.,  6590749.,  9883885., 10119109., 7178809.,  7414033.,
      10707169., 10942393., 8002093., 8237317.,  11530453., 11765677.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x15x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1421895., 1431450., 2228995., 2244626., 2402083., 2418946., 1530711.,
      1541834., 2123699., 2140786., 3136735., 3163018., 3126015., 3152186.,
      1912323., 1928290., 2954899., 2976130., 4188351., 4221146., 4013791.,
      4046474., 2251235., 2271346., 1892406., 1910628., 2829934., 2857620.,
      2906862., 2933748., 1873494., 1889860., 1734474., 1747068., 2569874.,
      2589900., 2587410., 2607980., 1596714., 1610140., 1818935., 1831234.,
      2834803., 2854746., 3007891., 3029066., 1912519., 1926386., 2219683.,
      2237498., 3406415., 3434354., 3477615., 3505442., 2210675., 2227882.,
      2764163., 2786122., 4048431., 4082882., 3955791., 3990130., 2303827.,
      2325178., 1834870., 1850356., 2825262., 2849892., 2921646., 2947012.,
      1908886., 1925588., 1375626., 1387500., 1984594., 2003196., 1931474.,
      1950108., 1207402., 1219596., 2215975., 2231018., 3324899., 3348642.,
      3055619., 3078546., 1777207., 1791258., 2473363., 2491906., 3880895.,
      3910490., 4034015., 4063498., 2623715., 2642162., 2731123., 2753810.,
      4113311., 4149418., 4102591., 4138586., 2471107., 2493698., 1999542.,
      2015876., 3090926., 3116596., 3200622., 3226516., 2101974., 2119012.,
      1131466., 1142620., 1604114., 1621292., 1523346., 1540044., 975786.,
      986748.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x15x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3136735., 3163018., 3126015., 3152186., 4188351., 4221146.,
      4013791., 4046474., 3406415., 3434354., 3477615., 3505442.,
      4048431., 4082882., 3955791., 3990130., 3880895., 3910490.,
      4034015., 4063498., 4113311., 4149418., 4102591., 4138586.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x15x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1278011., 1287566., 1297121., 1306676., 1993207., 2008838., 2024469.,
      2040100., 2153831., 2170694., 2187557., 2204420., 1423163., 1434286.,
      1445409., 1456532., 2340263., 2357350., 2374437., 2391524., 3696659.,
      3722942., 3749225., 3775508., 3441859., 3468030., 3494201., 3520372.,
      1889447., 1905414., 1921381., 1937348., 2773815., 2795046., 2816277.,
      2837508., 3864163., 3896958., 3929753., 3962548., 3805971., 3838654.,
      3871337., 3904020., 2247735., 2267846., 2287957., 2308068., 2175806.,
      2194028., 2212250., 2230472., 3246774., 3274460., 3302146., 3329832.,
      3344086., 3370972., 3397858., 3424744., 2282686., 2299052., 2315418.,
      2331784., 1673570., 1686164., 1698758., 1711352., 2375402., 2395428.,
      2415454., 2435480., 2409930., 2430500., 2451070., 2471640., 1436386.,
      1449812., 1463238., 1476664., 1653603., 1665902., 1678201., 1690500.,
      2555391., 2575334., 2595277., 2615220., 2716015., 2737190., 2758365.,
      2779540., 1782627., 1796494., 1810361., 1824228., 2394287., 2412102.,
      2429917., 2447732., 3417211., 3445150., 3473089., 3501028., 3326251.,
      3354078., 3381905., 3409732., 1983151., 2000358., 2017565., 2034772.,
      2778687., 2800646., 2822605., 2844564., 4076235., 4110686., 4145137.,
      4179588., 4181883., 4216222., 4250561., 4284900., 2636351., 2657702.,
      2679053., 2700404., 2157678., 2173164., 2188650., 2204136., 3105318.,
      3129948., 3154578., 3179208., 3108934., 3134300., 3159666., 3185032.,
      1951726., 1968428., 1985130., 2001832., 1456306., 1468180., 1480054.,
      1491928., 2058234., 2076836., 2095438., 2114040., 2083034., 2101668.,
      2120302., 2138936., 1275442., 1287636., 1299830., 1312024., 2029195.,
      2044238., 2059281., 2074324., 3017735., 3041478., 3065221., 3088964.,
      2819959., 2842886., 2865813., 2888740., 1765771., 1779822., 1793873.,
      1807924., 2370487., 2389030., 2407573., 2426116., 3547363., 3576958.,
      3606553., 3636148., 3620243., 3649726., 3679209., 3708692., 2306231.,
      2324678., 2343125., 2361572., 3098951., 3121638., 3144325., 3167012.,
      4697907., 4734014., 4770121., 4806228., 4443107., 4479102., 4515097.,
      4551092., 2598983., 2621574., 2644165., 2666756., 2056094., 2072428.,
      2088762., 2105096., 2976150., 3001820., 3027490., 3053160., 3006902.,
      3032796., 3058690., 3084584., 1936158., 1953196., 1970234., 1987272.,
      1468418., 1479572., 1490726., 1501880., 2150666., 2167844., 2185022.,
      2202200., 2251754., 2268452., 2285150., 2301848., 1429890., 1440852.,
      1451814., 1462776.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x15x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3696659., 3722942., 3749225., 3775508., 3441859., 3468030., 3494201.,
      3520372., 3864163., 3896958., 3929753., 3962548., 3805971., 3838654.,
      3871337., 3904020., 3417211., 3445150., 3473089., 3501028., 3326251.,
      3354078., 3381905., 3409732., 4076235., 4110686., 4145137., 4179588.,
      4181883., 4216222., 4250561., 4284900., 3547363., 3576958., 3606553.,
      3636148., 3620243., 3649726., 3679209., 3708692., 4697907., 4734014.,
      4770121., 4806228., 4443107., 4479102., 4515097., 4551092.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x15x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2519646., 3862438., 4129222., 2809086., 4805094., 6778382., 6473134.,
      3978758., 4936134., 7103598., 6778382., 3824614., 4163204., 6344436.,
      6237876., 3790660., 2679708., 4105388., 4286188., 2764508., 3430286.,
      5347094., 5777718., 3865134., 4922710., 7205054., 7227486., 4545398.,
      4647734., 7107870., 7205054., 4365142., 3496484., 5493780., 5733332.,
      3648740., 2346236., 3602060., 3759308., 2535484., 4570302., 7009414.,
      6717094., 4199774., 5585094., 8450926., 8569102., 5441254., 5090470.,
      8052174., 8450926., 5364422., 3593156., 5683508., 6168820., 4051588.,
      2460764., 3761772., 3863212., 2656668.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x15x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6778382., 6473134., 7103598., 6778382., 7205054., 7227486.,
      7107870., 7205054., 8450926., 8569102., 8052174., 8450926.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x15x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3264978., 3285692., 4472234., 4504908., 4267690., 4301196., 2771090.,
      2793980., 4916074., 4952524., 7522402., 7578140., 7027042., 7082332.,
      3933482., 3968524., 4995690., 5034380., 7268194., 7327452., 7522402.,
      7578140., 4199466., 4233676., 4302044., 4337928., 6522412., 6578664.,
      6605356., 6660456., 4391772., 4425352., 2412228., 2432824., 3507444.,
      3541336., 3606772., 3640792., 2213444., 2235320., 3418450., 3443996.,
      4854058., 4893740., 4977194., 5017708., 3273746., 3300444., 5384938.,
      5425324., 7721954., 7784316., 7881954., 7943868., 4890794., 4929772.,
      4919786., 4957292., 7414498., 7475260., 7721954., 7784316., 4841386.,
      4880556., 4136668., 4167752., 6120492., 6171688., 6367276., 6421416.,
      4072796., 4108744., 2175172., 2191864., 3293940., 3321112., 3606260.,
      3635608., 2388036., 2408056., 4030674., 4061052., 5854378., 5900044.,
      5584298., 5626700., 3649426., 3674812., 6156906., 6201228., 8511330.,
      8580316., 8077410., 8144924., 4934698., 4976588., 5515626., 5556044.,
      8650338., 8716700., 8511330., 8580316., 5090090., 5134220., 4442332.,
      4475784., 6742572., 6796904., 7218732., 7276008., 4581212., 4619528.,
      2826948., 2846904., 4395252., 4426968., 4859124., 4891992., 3258948.,
      3281208.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x15x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7522402., 7578140., 7027042., 7082332., 7268194., 7327452.,
      7522402., 7578140., 7721954., 7784316., 7881954., 7943868.,
      7414498., 7475260., 7721954., 7784316., 8511330., 8580316.,
      8077410., 8144924., 8650338., 8716700., 8511330., 8580316.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x15x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2782906., 2803620., 2824334., 2845048., 4006322., 4038996., 4071670.,
      4104344., 3973234., 4006740., 4040246., 4073752., 2626490., 2649380.,
      2672270., 2695160., 4228210., 4264660., 4301110., 4337560., 7699722.,
      7755460., 7811198., 7866936., 6824138., 6879428., 6934718., 6990008.,
      3933042., 3968084., 4003126., 4038168., 4286898., 4325588., 4364278.,
      4402968., 7073098., 7132356., 7191614., 7250872., 7699722., 7755460.,
      7811198., 7866936., 3990706., 4024916., 4059126., 4093336., 4095884.,
      4131768., 4167652., 4203536., 6492316., 6548568., 6604820., 6661072.,
      6659356., 6714456., 6769556., 6824656., 4708236., 4741816., 4775396.,
      4808976., 2333972., 2354568., 2375164., 2395760., 3769732., 3803624.,
      3837516., 3871408., 3706116., 3740136., 3774156., 3808176., 2353428.,
      2375304., 2397180., 2419056., 2937562., 2963108., 2988654., 3014200.,
      5033298., 5072980., 5112662., 5152344., 5131282., 5171796., 5212310.,
      5252824., 3185626., 3212324., 3239022., 3265720., 4850706., 4891092.,
      4931478., 4971864., 7445034., 7507396., 7569758., 7632120., 7880170.,
      7942084., 8003998., 8065912., 4885266., 4924244., 4963222., 5002200.,
      4611410., 4648916., 4686422., 4723928., 7241322., 7302084., 7362846.,
      7423608., 7445034., 7507396., 7569758., 7632120., 4835410., 4874580.,
      4913750., 4952920., 4122188., 4153272., 4184356., 4215440., 6348892.,
      6400088., 6451284., 6502480., 6577372., 6631512., 6685652., 6739792.,
      4182604., 4218552., 4254500., 4290448., 2060372., 2077064., 2093756.,
      2110448., 3611588., 3638760., 3665932., 3693104., 3709764., 3739112.,
      3768460., 3797808., 2401364., 2421384., 2441404., 2461424., 3747578.,
      3777956., 3808334., 3838712., 5463282., 5508948., 5554614., 5600280.,
      5303218., 5345620., 5388022., 5430424., 3758074., 3783460., 3808846.,
      3834232., 5817266., 5861588., 5905910., 5950232., 8369994., 8438980.,
      8507966., 8576952., 7880458., 7947972., 8015486., 8083000., 5060274.,
      5102164., 5144054., 5185944., 5226738., 5267156., 5307574., 5347992.,
      8535946., 8602308., 8668670., 8735032., 8369994., 8438980., 8507966.,
      8576952., 5155826., 5199956., 5244086., 5288216., 4296972., 4330424.,
      4363876., 4397328., 7458844., 7513176., 7567508., 7621840., 7621788.,
      7679064., 7736340., 7793616., 4787468., 4825784., 4864100., 4902416.,
      2508692., 2528648., 2548604., 2568560., 3974660., 4006376., 4038092.,
      4069808., 4376964., 4409832., 4442700., 4475568., 3051412., 3073672.,
      3095932., 3118192.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x15x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7699722., 7755460., 7811198., 7866936., 6824138., 6879428., 6934718.,
      6990008., 7073098., 7132356., 7191614., 7250872., 7699722., 7755460.,
      7811198., 7866936., 7445034., 7507396., 7569758., 7632120., 7880170.,
      7942084., 8003998., 8065912., 7241322., 7302084., 7362846., 7423608.,
      7445034., 7507396., 7569758., 7632120., 8369994., 8438980., 8507966.,
      8576952., 7880458., 7947972., 8015486., 8083000., 8535946., 8602308.,
      8668670., 8735032., 8369994., 8438980., 8507966., 8576952.};
  const std::array<int, 4> in_shape = {{3, 18, 15, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x16x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      288148.,  406483.,  432047.,  276801.,  620092.,  856317.,  885841.,
      558327.,  972092.,  1328701., 1358225., 849079.,  1049100., 1424555.,
      1448975., 899605.,  422212.,  562969.,  571813.,  345863.,  1650964.,
      2247091., 2272655., 1419873., 2204092., 2982045., 3011569., 1866711.,
      2556092., 3454429., 3483953., 2157463., 2362380., 3182795., 3207215.,
      1978165., 906052.,  1199737., 1208581., 726887.,  3013780., 4087699.,
      4113263., 2562945., 3788092., 5107773., 5137297., 3175095., 4140092.,
      5580157., 5609681., 3465847., 3675660., 4941035., 4965455., 3056725.,
      1389892., 1836505., 1845349., 1107911.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x16x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      848936.,  878460.,  1321320., 1350844., 2974664., 3004188.,
      3447048., 3476572., 5100392., 5129916., 5572776., 5602300.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x16x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      573356.,   576296.,   808731.,   812966.,   859551.,  864094.,  550613.,
      553602.,   1232748.,  1240184.,  1702107.,  1712634., 1760671., 1771682.,
      1109493.,  1116654.,  1931116.,  1944184.,  2639131., 2657402., 2697695.,
      2716450.,  1686069.,  1698158.,  2081840.,  2098200., 2826340., 2849110.,
      2874740.,  2897950.,  1784300.,  1799210.,  833072.,  844424.,  1110164.,
      1125938.,  1127588.,  1143626.,  681436.,   691726.,  3282860., 3301928.,
      4467771.,  4494182.,  4518591.,  4545310.,  2822645., 2839746., 4375404.,
      4408184.,  5918715.,  5964090.,  5977279.,  6023138., 3704085., 3733422.,
      5073772.,  5112184.,  6855739.,  6908858.,  6914303., 6967906., 4280661.,
      4314926.,  4685360.,  4724760.,  6311140.,  6365590., 6359540., 6414430.,
      3921260.,  3956330.,  1786928.,  1812104.,  2364692., 2399474., 2382116.,
      2417162.,  1431388.,  1453774.,  5992364.,  6027560., 8126811., 8175398.,
      8177631.,  8226526.,  5094677.,  5125890.,  7518060., 7576184., 10135323.,
      10215546., 10193887., 10274594., 6298677.,  6350190., 8216428., 8280184.,
      11072347., 11160314., 11130911., 11219362., 6875253., 6931694., 7288880.,
      7351320.,  9795940.,  9882070.,  9844340.,  9930910., 6058220., 6113450.,
      2740784.,  2779784.,  3619220.,  3673010.,  3636644., 3690698., 2181340.,
      2215822.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x16x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1687466.,  1697872.,  1746030.,  1756920.,  2624490.,  2642640.,
      2683054.,  2701688.,  5904074.,  5949328.,  5962638.,  6008376.,
      6841098.,  6894096.,  6899662.,  6953144.,  10120682., 10200784.,
      10179246., 10259832., 11057706., 11145552., 11116270., 11204600.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x16x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1143772.,  1146712.,  1149652.,  1152592.,  1613227.,  1617462.,
      1621697.,  1625932.,  1714559.,  1719102.,  1723645.,  1728188.,
      1098237.,  1101226.,  1104215.,  1107204.,  2458060.,  2465496.,
      2472932.,  2480368.,  3393687.,  3404214.,  3414741.,  3425268.,
      3510331.,  3521342.,  3532353.,  3543364.,  2211825.,  2218986.,
      2226147.,  2233308.,  3849164.,  3862232.,  3875300.,  3888368.,
      5259991.,  5278262.,  5296533.,  5314804.,  5376635.,  5395390.,
      5414145.,  5432900.,  3360049.,  3372138.,  3384227.,  3396316.,
      4147320.,  4163680.,  4180040.,  4196400.,  5629910.,  5652680.,
      5675450.,  5698220.,  5726270.,  5749480.,  5772690.,  5795900.,
      3553690.,  3568600.,  3583510.,  3598420.,  1654792.,  1666144.,
      1677496.,  1688848.,  2204554.,  2220328.,  2236102.,  2251876.,
      2239138.,  2255176.,  2271214.,  2287252.,  1352582.,  1362872.,
      1373162.,  1383452.,  6546652.,  6565720.,  6584788.,  6603856.,
      8909131.,  8935542.,  8961953.,  8988364.,  9010463.,  9037182.,
      9063901.,  9090620.,  5628189.,  5645290.,  5662391.,  5679492.,
      8718028.,  8750808.,  8783588.,  8816368.,  11792055., 11837430.,
      11882805., 11928180., 11908699., 11954558., 12000417., 12046276.,
      7378833.,  7408170.,  7437507.,  7466844.,  8196300.,  8230616.,
      8264932.,  8299248.,  11062007., 11109494., 11156981., 11204468.,
      11178651., 11226622., 11274593., 11322564., 6903505.,  6934186.,
      6964867.,  6995548.,  3482232.,  3505248.,  3528264.,  3551280.,
      4660502.,  4692424.,  4724346.,  4756268.,  4756862.,  4789224.,
      4821586.,  4853948.,  2890202.,  2910936.,  2931670.,  2952404.,
      583176.,   591968.,   600760.,   609552.,   752202.,   764456.,
      776710.,   788964.,   786786.,   799304.,   811822.,   824340.,
      446278.,   454328.,   462378.,   470428.,   2344412.,  2350936.,
      2357460.,  2363984.,  3234539.,  3243702.,  3252865.,  3262028.,
      3335871.,  3345342.,  3354813.,  3364284.,  2104893.,  2111018.,
      2117143.,  2123268.,  3849164.,  3862232.,  3875300.,  3888368.,
      5259991.,  5278262.,  5296533.,  5314804.,  5376635.,  5395390.,
      5414145.,  5432900.,  3360049.,  3372138.,  3384227.,  3396316.,
      5240268.,  5258968.,  5277668.,  5296368.,  7126295.,  7152310.,
      7178325.,  7204340.,  7242939.,  7269438.,  7295937.,  7322436.,
      4508273.,  4525290.,  4542307.,  4559324.,  5299320.,  5320800.,
      5342280.,  5363760.,  7171670.,  7201480.,  7231290.,  7261100.,
      7268030.,  7298280.,  7328530.,  7358780.,  4498970.,  4518360.,
      4537750.,  4557140.,  2075656.,  2090080.,  2104504.,  2118928.,
      2757898.,  2777896.,  2797894.,  2817892.,  2792482.,  2812744.,
      2833006.,  2853268.,  1683206.,  1696184.,  1709162.,  1722140.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x16x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3364526.,  3374932.,  3385338.,  3395744.,  3481170.,  3492060.,
      3502950.,  3513840.,  5230830.,  5248980.,  5267130.,  5285280.,
      5347474.,  5366108.,  5384742.,  5403376.,  11762894., 11808148.,
      11853402., 11898656., 11879538., 11925276., 11971014., 12016752.,
      11032846., 11080212., 11127578., 11174944., 11149490., 11197340.,
      11245190., 11293040., 5230830.,  5248980.,  5267130.,  5285280.,
      5347474.,  5366108.,  5384742.,  5403376.,  7097134.,  7123028.,
      7148922.,  7174816.,  7213778.,  7240156.,  7266534.,  7292912.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x16x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2289896., 3230689., 3434585.,  2200541.,  4934952.,  6814841., 7050065.,
      4443285., 7739688., 10578425., 10813649., 6759445.,  5049664., 6866992.,
      7061472., 4371248., 1492096.,  1978504.,  2048728.,  1216936., 3497704.,
      4861857., 5065753., 3213469.,  6337320.,  8696633.,  8931857., 5601365.,
      7221032., 9852601., 10087825., 6286805.,  3631424.,  4942256., 5136736.,
      3167920., 780416.,  1042184.,  1112408.,  656936.,   4705512., 6493025.,
      6696921., 4226397., 7739688.,  10578425., 10813649., 6759445., 5322024.,
      7262585., 7497809., 4656533.,  2934080.,  4008752.,  4203232., 2595376.,
      789632.,  1097096., 1167320.,  727720.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x16x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6756035., 6991259.,  10519619., 10754843., 8637827., 8873051.,
      9793795., 10029019., 10519619., 10754843., 7203779., 7439003.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x16x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1724952., 1736656., 2404067., 2420930., 2577155., 2595250., 1638455.,
      1650362., 2180216., 2197584., 3074543., 3099634., 3309583., 3336610.,
      2157715., 2175530., 2950264., 2973776., 4033519., 4067058., 4268559.,
      4304034., 2641555., 2664746., 1933616., 1949824., 2721542., 2744928.,
      2920326., 2945472., 1909166., 1925728., 1367504., 1380096., 1878234.,
      1896208., 2009434., 2028464., 1260210., 1272656., 1888792., 1903568.,
      2628579., 2649666., 2801667., 2823986., 1801527., 1816122., 3122296.,
      3142736., 4369135., 4398450., 4604175., 4635426., 3001747., 3022250.,
      2368632., 2391120., 3266799., 3298930., 3501839., 3535906., 2202515.,
      2224810., 2658608., 2676864., 3726086., 3752288., 3924870., 3952832.,
      2575790., 2594144., 1019344., 1029888., 1440986., 1456144., 1572186.,
      1588400., 1038002., 1048656., 1724952., 1738704., 2436323., 2456002.,
      2609411., 2630322., 1728055., 1741754., 2950264., 2973776., 4033519.,
      4067058., 4268559., 4304034., 2641555., 2664746., 2180216., 2197584.,
      3074543., 3099634., 3309583., 3336610., 2157715., 2175530., 2269488.,
      2289792., 3100422., 3129440., 3299206., 3329984., 2038190., 2058336.,
      1392080., 1400576., 1994970., 2007312., 2126170., 2139568., 1446578.,
      1455440.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x16x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3015783., 3040390., 3250823., 3277366., 3974759., 4007814.,
      4209799., 4244790., 4310375., 4339206., 4545415., 4576182.,
      3208039., 3239686., 3443079., 3476662., 3974759., 4007814.,
      4209799., 4244790., 3015783., 3040390., 3250823., 3277366.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x16x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1556344., 1568048., 1579752., 1591456., 2150631., 2167494., 2184357.,
      2201220., 2311255., 2329350., 2347445., 2365540., 1523179., 1535086.,
      1546993., 1558900., 2320152., 2337520., 2354888., 2372256., 3149531.,
      3174622., 3199713., 3224804., 3384203., 3411230., 3438257., 3465284.,
      2120335., 2138150., 2155965., 2173780., 2936600., 2960112., 2983624.,
      3007136., 3944923., 3978462., 4012001., 4045540., 4179595., 4215070.,
      4250545., 4286020., 2623887., 2647078., 2670269., 2693460., 2125072.,
      2141280., 2157488., 2173696., 2881714., 2905100., 2928486., 2951872.,
      3089106., 3114252., 3139398., 3164544., 1945258., 1961820., 1978382.,
      1994944., 1510768., 1523360., 1535952., 1548544., 2014078., 2032052.,
      2050026., 2068000., 2144350., 2163380., 2182410., 2201440., 1316294.,
      1328740., 1341186., 1353632., 1848184., 1862960., 1877736., 1892512.,
      2562663., 2583750., 2604837., 2625924., 2723287., 2745606., 2767925.,
      2790244., 1846635., 1861230., 1875825., 1890420., 2824984., 2845424.,
      2865864., 2886304., 3866715., 3896030., 3925345., 3954660., 4101387.,
      4132638., 4163889., 4195140., 2658831., 2679334., 2699837., 2720340.,
      2626328., 2648816., 2671304., 2693792., 3559771., 3591902., 3624033.,
      3656164., 3794443., 3828510., 3862577., 3896644., 2434831., 2457126.,
      2479421., 2501716., 2458896., 2477152., 2495408., 2513664., 3380658.,
      3406860., 3433062., 3459264., 3588050., 3616012., 3643974., 3671936.,
      2359210., 2377564., 2395918., 2414272., 1242480., 1253024., 1263568.,
      1274112., 1666686., 1681844., 1697002., 1712160., 1796958., 1813172.,
      1829386., 1845600., 1103046., 1113700., 1124354., 1135008., 1881976.,
      1895728., 1909480., 1923232., 2540007., 2559686., 2579365., 2599044.,
      2700631., 2721542., 2742453., 2763364., 1700587., 1714286., 1727985.,
      1741684., 2936600., 2960112., 2983624., 3007136., 3944923., 3978462.,
      4012001., 4045540., 4179595., 4215070., 4250545., 4286020., 2623887.,
      2647078., 2670269., 2693460., 2320152., 2337520., 2354888., 2372256.,
      3149531., 3174622., 3199713., 3224804., 3384203., 3411230., 3438257.,
      3465284., 2120335., 2138150., 2155965., 2173780., 2399504., 2419808.,
      2440112., 2460416., 3240626., 3269644., 3298662., 3327680., 3448018.,
      3478796., 3509574., 3540352., 2199722., 2219868., 2240014., 2260160.,
      1236336., 1244832., 1253328., 1261824., 1728894., 1741236., 1753578.,
      1765920., 1859166., 1872564., 1885962., 1899360., 1233862., 1242724.,
      1251586., 1260448.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x16x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3090863., 3115470., 3140077., 3164684., 3325535., 3352078., 3378621.,
      3405164., 3886255., 3919310., 3952365., 3985420., 4120927., 4155918.,
      4190909., 4225900., 3808047., 3836878., 3865709., 3894540., 4042719.,
      4073486., 4104253., 4135020., 3501103., 3532750., 3564397., 3596044.,
      3735775., 3769358., 3802941., 3836524., 3886255., 3919310., 3952365.,
      3985420., 4120927., 4155918., 4190909., 4225900., 3090863., 3115470.,
      3140077., 3164684., 3325535., 3352078., 3378621., 3405164.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x16x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2766032., 4137158., 4831974., 3241630., 4588304., 6693118., 7637150.,
      4964022., 4588304., 6693118., 7637150., 4964022., 3602976., 5282236.,
      6080892., 3970092., 2386400., 3545028., 4071940., 2747220., 4209872.,
      6186950., 6881766., 4684190., 5311248., 7751678., 8695710., 5775798.,
      5311248., 7751678., 8695710., 5775798., 5196320., 7503804., 8302460.,
      5493292., 3258848., 4775364., 5302276., 3639636., 2766032., 4137158.,
      4831974., 3241630., 4588304., 6693118., 7637150., 4964022., 4588304.,
      6693118., 7637150., 4964022., 3602976., 5282236., 6080892., 3970092.,
      2386400., 3545028., 4071940., 2747220.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x16x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6457110., 7401142., 6457110., 7401142., 7515670., 8459702.,
      7515670., 8459702., 6457110., 7401142., 6457110., 7401142.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x16x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2980144., 3002272., 4254890., 4288396., 4902314., 4940748., 3174290.,
      3200316., 4739952., 4776480., 6705378., 6760444., 7651810., 7714620.,
      4864426., 4906860., 4739952., 4776480., 6705378., 6760444., 7651810.,
      7714620., 4864426., 4906860., 3957664., 3989568., 5630700., 5678968.,
      6467308., 6522616., 4161052., 4198488., 2279776., 2297280., 3327796.,
      3354504., 3853108., 3884040., 2552452., 2573480., 3635504., 3661728.,
      5334186., 5373324., 5981610., 6025676., 4220818., 4250428., 5133168.,
      5173792., 7375074., 7435772., 8321506., 8389948., 5566890., 5612908.,
      5133168., 5173792., 7375074., 7435772., 8321506., 8389948., 5566890.,
      5612908., 5039008., 5079104., 7178988., 7238520., 8015596., 8082168.,
      5365276., 5409880., 3361120., 3386816., 4728628., 4766600., 5253940.,
      5296136., 3412612., 3440808., 2980144., 3002272., 4254890., 4288396.,
      4902314., 4940748., 3174290., 3200316., 4739952., 4776480., 6705378.,
      6760444., 7651810., 7714620., 4864426., 4906860., 4739952., 4776480.,
      6705378., 6760444., 7651810., 7714620., 4864426., 4906860., 3957664.,
      3989568., 5630700., 5678968., 6467308., 6522616., 4161052., 4198488.,
      2279776., 2297280., 3327796., 3354504., 3853108., 3884040., 2552452.,
      2573480.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x16x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6468770., 6521900., 7415202., 7476076., 6468770., 6521900.,
      7415202., 7476076., 7138466., 7197228., 8084898., 8151404.,
      7138466., 7197228., 8084898., 8151404., 6468770., 6521900.,
      7415202., 7476076., 6468770., 6521900., 7415202., 7476076.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x16x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2390000., 2412128., 2434256., 2456384., 3964018., 3997524., 4031030.,
      4064536., 4582194., 4620628., 4659062., 4697496., 3007866., 3033892.,
      3059918., 3085944., 4354608., 4391136., 4427664., 4464192., 6664362.,
      6719428., 6774494., 6829560., 7615594., 7678404., 7741214., 7804024.,
      4837266., 4879700., 4922134., 4964568., 4354608., 4391136., 4427664.,
      4464192., 6664362., 6719428., 6774494., 6829560., 7615594., 7678404.,
      7741214., 7804024., 4837266., 4879700., 4922134., 4964568., 3978400.,
      4010304., 4042208., 4074112., 5982540., 6030808., 6079076., 6127344.,
      6862284., 6917592., 6972900., 7028208., 4369916., 4407352., 4444788.,
      4482224., 2398816., 2416320., 2433824., 2451328., 3405332., 3432040.,
      3458748., 3485456., 3927444., 3958376., 3989308., 4020240., 2548964.,
      2569992., 2591020., 2612048., 3434480., 3460704., 3486928., 3513152.,
      5199474., 5238612., 5277750., 5316888., 5817650., 5861716., 5905782.,
      5949848., 4048762., 4078372., 4107982., 4137592., 5005872., 5046496.,
      5087120., 5127744., 7604906., 7665604., 7726302., 7787000., 8556138.,
      8624580., 8693022., 8761464., 5845394., 5891412., 5937430., 5983448.,
      5005872., 5046496., 5087120., 5127744., 7604906., 7665604., 7726302.,
      7787000., 8556138., 8624580., 8693022., 8761464., 5845394., 5891412.,
      5937430., 5983448., 4953248., 4993344., 5033440., 5073536., 7494988.,
      7554520., 7614052., 7673584., 8374732., 8441304., 8507876., 8574448.,
      5722620., 5767224., 5811828., 5856432., 2980448., 3006144., 3031840.,
      3057536., 4622868., 4660840., 4698812., 4736784., 5144980., 5187176.,
      5229372., 5271568., 3606756., 3634952., 3663148., 3691344., 2390000.,
      2412128., 2434256., 2456384., 3964018., 3997524., 4031030., 4064536.,
      4582194., 4620628., 4659062., 4697496., 3007866., 3033892., 3059918.,
      3085944., 4354608., 4391136., 4427664., 4464192., 6664362., 6719428.,
      6774494., 6829560., 7615594., 7678404., 7741214., 7804024., 4837266.,
      4879700., 4922134., 4964568., 4354608., 4391136., 4427664., 4464192.,
      6664362., 6719428., 6774494., 6829560., 7615594., 7678404., 7741214.,
      7804024., 4837266., 4879700., 4922134., 4964568., 3978400., 4010304.,
      4042208., 4074112., 5982540., 6030808., 6079076., 6127344., 6862284.,
      6917592., 6972900., 7028208., 4369916., 4407352., 4444788., 4482224.,
      2398816., 2416320., 2433824., 2451328., 3405332., 3432040., 3458748.,
      3485456., 3927444., 3958376., 3989308., 4020240., 2548964., 2569992.,
      2591020., 2612048.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x16x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6426554., 6479684., 6532814., 6585944., 7377786., 7438660., 7499534.,
      7560408., 6426554., 6479684., 6532814., 6585944., 7377786., 7438660.,
      7499534., 7560408., 7367098., 7425860., 7484622., 7543384., 8318330.,
      8384836., 8451342., 8517848., 7367098., 7425860., 7484622., 7543384.,
      8318330., 8384836., 8451342., 8517848., 6426554., 6479684., 6532814.,
      6585944., 7377786., 7438660., 7499534., 7560408., 6426554., 6479684.,
      6532814., 6585944., 7377786., 7438660., 7499534., 7560408.};
  const std::array<int, 4> in_shape = {{3, 18, 16, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x18x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      280574.,  445214.,  470778.,  445830.,  268366.,  608762.,  949366.,
      978890.,  907500.,  538208.,  958034.,  1480798., 1510322., 1386660.,
      816200.,  1036350., 1591040., 1615460., 1475925., 862975.,  419538.,
      629112.,  637956.,  578655.,  329469.,  1630034., 2515898., 2541462.,
      2316930., 1363810., 2180486., 3340810., 3370334., 3063720., 1789172.,
      2529758., 3872242., 3901766., 3542880., 2067164., 2340450., 3569060.,
      3593480., 3257925., 1893295., 902622.,  1345476., 1354320., 1220175.,
      691053.,  2979494., 4586582., 4612146., 4188030., 2459254., 3752210.,
      5732254., 5761778., 5219940., 3040136., 4101482., 6263686., 6293210.,
      5699100., 3318128., 3644550., 5547080., 5571500., 5039925., 2923615.,
      1385706., 2061840., 2070684., 1861695., 1052637.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x18x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      949366.,  978890.,  1480798., 1510322., 3340810., 3370334.,
      3872242., 3901766., 5732254., 5761778., 6263686., 6293210.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x18x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      558306.,   561148.,   885808.,   890428.,   936628.,   941556.,
      886935.,   891660.,   533813.,   536732.,   1210286.,  1217524.,
      1887116.,  1898732.,  1945680.,  1957780.,  1803615.,  1815000.,
      1069453.,  1076416.,  1903286.,  1916068.,  2941268.,  2961596.,
      2999832.,  3020644.,  2754015.,  2773320.,  1620685.,  1632400.,
      2056670.,  2072700.,  3156670.,  3182080.,  3205070.,  3230920.,
      2928000.,  2951850.,  1711520.,  1725950.,  827946.,   839076.,
      1240602.,  1258224.,  1258026.,  1275912.,  1140840.,  1157310.,
      648984.,   658938.,   3241350.,  3260068.,  5002228.,  5031796.,
      5053048.,  5082924.,  4606455.,  4633860.,  2711093.,  2727620.,
      4328786.,  4360972.,  6630800.,  6681620.,  6689364.,  6740668.,
      6080415.,  6127440.,  3549997.,  3578344.,  5021786.,  5059516.,
      7684952.,  7744484.,  7743516.,  7803532.,  7030815.,  7085760.,
      4101229.,  4134328.,  4642190.,  4680900.,  7077070.,  7138120.,
      7125470.,  7186960.,  6459600.,  6515850.,  3752720.,  3786590.,
      1780506.,  1805244.,  2651946.,  2690952.,  2669370.,  2708640.,
      2404440.,  2440350.,  1360488.,  1382106.,  5924394.,  5958988.,
      9118648.,  9173164.,  9169468.,  9224292.,  8325975.,  8376060.,
      4888373.,  4918508.,  7447286.,  7504420.,  11374484., 11464508.,
      11433048., 11523556., 10357215., 10439880., 6030541.,  6080272.,
      8140286.,  8202964.,  12428636., 12527372., 12487200., 12586420.,
      11307615., 11398200., 6581773.,  6636256.,  7227710.,  7289100.,
      10997470., 11094160., 11045870., 11143000., 9991200.,  10079850.,
      5793920.,  5847230.,  2733066.,  2771412.,  4063290.,  4123680.,
      4080714.,  4141368.,  3668040.,  3723390.,  2071992.,  2105274.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x18x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1887116.,  1898732.,  1945680.,  1957780.,  2941268.,  2961596.,
      2999832.,  3020644.,  6630800.,  6681620.,  6689364.,  6740668.,
      7684952.,  7744484.,  7743516.,  7803532.,  11374484., 11464508.,
      11433048., 11523556., 12428636., 12527372., 12487200., 12586420.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x18x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1113770.,  1116612.,  1119454.,  1122296.,  1766996.,  1771616.,
      1776236.,  1780856.,  1868328.,  1873256.,  1878184.,  1883112.,
      1769145.,  1773870.,  1778595.,  1783320.,  1064707.,  1067626.,
      1070545.,  1073464.,  2413334.,  2420572.,  2427810.,  2435048.,
      3762616.,  3774232.,  3785848.,  3797464.,  3879260.,  3891360.,
      3903460.,  3915560.,  3595845.,  3607230.,  3618615.,  3630000.,
      2131943.,  2138906.,  2145869.,  2152832.,  3793790.,  3806572.,
      3819354.,  3832136.,  5862208.,  5882536.,  5902864.,  5923192.,
      5978852.,  5999664.,  6020476.,  6041288.,  5488725.,  5508030.,
      5527335.,  5546640.,  3229655.,  3241370.,  3253085.,  3264800.,
      4097310.,  4113340.,  4129370.,  4145400.,  6287930.,  6313340.,
      6338750.,  6364160.,  6384290.,  6410140.,  6435990.,  6461840.,
      5832150.,  5856000.,  5879850.,  5903700.,  3408610.,  3423040.,
      3437470.,  3451900.,  1644762.,  1655892.,  1667022.,  1678152.,
      2463582.,  2481204.,  2498826.,  2516448.,  2498166.,  2516052.,
      2533938.,  2551824.,  2265210.,  2281680.,  2298150.,  2314620.,
      1288014.,  1297968.,  1307922.,  1317876.,  6463982.,  6482700.,
      6501418.,  6520136.,  9974888.,  10004456., 10034024., 10063592.,
      10076220., 10106096., 10135972., 10165848., 9185505.,  9212910.,
      9240315.,  9267720.,  5405659.,  5422186.,  5438713.,  5455240.,
      8625386.,  8657572.,  8689758.,  8721944.,  12478108., 12527392.,
      12576676., 12625960., 11646528., 11694248., 11741968., 11789688.,
      9763725.,  9805630.,  9847535.,  9889440.,  5686175.,  5711450.,
      5736725.,  5762000.,  4228434.,  4251828.,  4275222.,  4298616.,
      5949476.,  5984944.,  6020412.,  6055880.,  5478344.,  5512248.,
      5546152.,  5580056.,  4509085.,  4538430.,  4567775.,  4597120.,
      2593679.,  2611418.,  2629157.,  2646896.,  1894886.,  1908508.,
      1922130.,  1935752.,  2665250.,  2685340.,  2705430.,  2725520.,
      2534282.,  2552764.,  2571246.,  2589728.,  2172390.,  2187680.,
      2202970.,  2218260.,  1253842.,  1263136.,  1272430.,  1281724.,
      547218.,   550452.,   553686.,   556920.,   838134.,   843348.,
      848562.,   853776.,   872718.,   878196.,   883674.,   889152.,
      810090.,   815280.,   820470.,   825660.,   469086.,   472272.,
      475458.,   478644.,   3359538.,  3369044.,  3378550.,  3388056.,
      5212284.,  5227376.,  5242468.,  5257560.,  5313616.,  5329016.,
      5344416.,  5359816.,  4882185.,  4896430.,  4910675.,  4924920.,
      2886835.,  2895466.,  2904097.,  2912728.,  5020862.,  5038572.,
      5056282.,  5073992.,  7728512.,  7756584.,  7784656.,  7812728.,
      7845156.,  7873712.,  7902268.,  7930824.,  7171285.,  7197630.,
      7223975.,  7250320.,  4205399.,  4221338.,  4237277.,  4253216.,
      6401318.,  6424572.,  6447826.,  6471080.,  9828104.,  9864888.,
      9901672.,  9938456.,  9944748.,  9982016.,  10019284., 10056552.,
      9064165.,  9098430.,  9132695.,  9166960.,  5303111.,  5323802.,
      5344493.,  5365184.,  6258350.,  6283900.,  6309450.,  6335000.,
      9564170.,  9604540.,  9644910.,  9685280.,  9660530.,  9701340.,
      9742150.,  9782960.,  8783350.,  8820800.,  8858250.,  8895700.,
      5114050.,  5136640.,  5159230.,  5181820.,  2438730.,  2455572.,
      2472414.,  2489256.,  3639438.,  3666036.,  3692634.,  3719232.,
      3674022.,  3700884.,  3727746.,  3754608.,  3317850.,  3342480.,
      3367110.,  3391740.,  1880430.,  1895280.,  1910130.,  1924980.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x18x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3762616.,  3774232.,  3785848.,  3797464.,  3879260.,  3891360.,
      3903460.,  3915560.,  5862208.,  5882536.,  5902864.,  5923192.,
      5978852.,  5999664.,  6020476.,  6041288.,  12478108., 12527392.,
      12576676., 12625960., 11646528., 11694248., 11741968., 11789688.,
      5949476.,  5984944.,  6020412.,  6055880.,  5478344.,  5512248.,
      5546152.,  5580056.,  7728512.,  7756584.,  7784656.,  7812728.,
      7845156.,  7873712.,  7902268.,  7930824.,  9828104.,  9864888.,
      9901672.,  9938456.,  9944748.,  9982016.,  10019284., 10056552.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x18x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2230627., 3539767., 3743663.,  3545710.,  2134370.,  4845995., 7557055.,
      7792279., 7224030., 4284082.,  6893339.,  10103023., 9418695., 8681150.,
      5106898., 3667336., 5272120.,  4907496.,  4560320.,  2653856., 910368.,
      1204496., 1076064., 1008400.,  561552.,   4489723.,  7005999., 7209895.,
      6677790., 3967922., 7474467.,  10820119., 10103023., 8469070., 4983874.,
      4451475., 6380871., 6024223.,  5098030.,  2983522.,  3029880., 4461800.,
      4424856., 3954720., 2323520.,  1104432.,  1692768.,  1762992., 1637040.,
      948720.,  6748819., 10472231., 9940383.,  8369102.,  4409858., 4296859.,
      6611055., 6380871., 5445054.,  2860498.,  3797003.,  5866399., 5906551.,
      5318046., 3022834., 4403560.,  6831000.,  7025480.,  6492800., 3830240.,
      1909824., 2886576., 2956800.,  2706000.,  1550928.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x18x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7557055., 7792279., 10103023., 9418695., 10820119., 10103023.,
      6380871., 6024223., 6611055.,  6380871., 5866399.,  5906551.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x18x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1685391., 1696710., 2624395., 2642798., 2797483., 2817118., 2671182.,
      2690012., 1576786., 1588420., 2122635., 2138198., 3331959., 3356798.,
      3509655., 3535406., 3414854., 3439804., 2050778., 2066276., 2590667.,
      2612534., 3625399., 3658974., 3327959., 3360398., 3190598., 3221628.,
      1852634., 1871780., 2173662., 2189584., 3408342., 3433072., 3574358.,
      3598800., 3461180., 3484800., 2085892., 2100544., 1083522., 1094208.,
      1563914., 1580064., 1498506., 1513664., 1492484., 1507104., 899004.,
      908064.,  1737903., 1751286., 2609579., 2629470., 2643403., 2662478.,
      2538830., 2556220., 1546066., 1556836., 3111083., 3135302., 4119447.,
      4155182., 3625399., 3658974., 2977094., 3006364., 1730522., 1748612.,
      2518251., 2536486., 3909079., 3937166., 4078583., 4106558., 3912006.,
      3937116., 2355674., 2371268., 2407518., 2429680., 3384918., 3418576.,
      3002070., 3033392., 2431676., 2457920., 1335172., 1350784., 1941506.,
      1954400., 3099018., 3119296., 2845194., 2864480., 2246020., 2262624.,
      1172028., 1181664., 1912271., 1925158., 2970571., 2991438., 2802667.,
      2823230., 2336846., 2354844., 1158994., 1168900., 2361803., 2378806.,
      3744695., 3772382., 3909079., 3937166., 3731270., 3756668., 2233562.,
      2248100., 2321931., 2343190., 3562999., 3597374., 3511319., 3545582.,
      2908998., 2938428., 1470170., 1486308., 2373086., 2389200., 3773142.,
      3799344., 3968854., 3996304., 3437884., 3462656., 1809156., 1823680.,
      1025922., 1035904., 1629706., 1645920., 1716874., 1733632., 1578244.,
      1592736., 916668.,  924832.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x18x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3331959., 3356798., 3509655., 3535406., 3625399., 3658974.,
      3327959., 3360398., 4119447., 4155182., 3625399., 3658974.,
      3909079., 3937166., 4078583., 4106558., 3744695., 3772382.,
      3909079., 3937166., 3562999., 3597374., 3511319., 3545582.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x18x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1514471., 1525790., 1537109., 1548428., 2345011., 2363414., 2381817.,
      2400220., 2505635., 2525270., 2544905., 2564540., 2422798., 2441628.,
      2460458., 2479288., 1440050., 1451684., 1463318., 1474952., 2017099.,
      2032662., 2048225., 2063788., 2991847., 3016686., 3041525., 3066364.,
      3112855., 3138606., 3164357., 3190108., 3076118., 3101068., 3126018.,
      3150968., 1762090., 1777588., 1793086., 1808584., 2840363., 2862230.,
      2884097., 2905964., 4086087., 4119662., 4153237., 4186812., 4045303.,
      4077742., 4110181., 4142620., 3973206., 4004236., 4035266., 4066296.,
      2296042., 2315188., 2334334., 2353480., 2026890., 2042812., 2058734.,
      2074656., 3041554., 3066284., 3091014., 3115744., 3185458., 3209900.,
      3234342., 3258784., 3166516., 3190136., 3213756., 3237376., 1853132.,
      1867784., 1882436., 1897088., 1499974., 1510660., 1521346., 1532032.,
      1952510., 1968660., 1984810., 2000960., 1691614., 1706772., 1721930.,
      1737088., 1649644., 1664264., 1678884., 1693504., 918036.,  927096.,
      936156.,  945216.,  1826327., 1839710., 1853093., 1866476., 2457251.,
      2477142., 2497033., 2516924., 2341395., 2360470., 2379545., 2398620.,
      2188206., 2205596., 2222986., 2240376., 1281170., 1291940., 1302710.,
      1313480., 3112891., 3137110., 3161329., 3185548., 4256919., 4292654.,
      4328389., 4364124., 4086087., 4119662., 4153237., 4186812., 3756854.,
      3786124., 3815394., 3844664., 2175754., 2193844., 2211934., 2230024.,
      2351003., 2369238., 2387473., 2405708., 3442423., 3470510., 3498597.,
      3526684., 3548071., 3576046., 3604021., 3631996., 3443574., 3468684.,
      3493794., 3518904., 2003146., 2018740., 2034334., 2049928., 2889770.,
      2911932., 2934094., 2956256., 4108082., 4141740., 4175398., 4209056.,
      3680594., 3711916., 3743238., 3774560., 3099636., 3125880., 3152124.,
      3178368., 1825292., 1840904., 1856516., 1872128., 1821094., 1833988.,
      1846882., 1859776., 2790366., 2810644., 2830922., 2851200., 2545854.,
      2565140., 2584426., 2603712., 2052908., 2069512., 2086116., 2102720.,
      996564.,  1006200., 1015836., 1025472., 1729095., 1741982., 1754869.,
      1767756., 2666259., 2687126., 2707993., 2728860., 2539651., 2560214.,
      2580777., 2601340., 2205518., 2223516., 2241514., 2259512., 1196018.,
      1205924., 1215830., 1225736., 2190891., 2207894., 2224897., 2241900.,
      3347527., 3375214., 3402901., 3430588., 3442423., 3470510., 3498597.,
      3526684., 3290710., 3316108., 3341506., 3366904., 1882858., 1897396.,
      1911934., 1926472., 2786827., 2808086., 2829345., 2850604., 4279975.,
      4314350., 4348725., 4383100., 4205399., 4239662., 4273925., 4308188.,
      3518102., 3547532., 3576962., 3606392., 1812650., 1828788., 1844926.,
      1861064., 2179786., 2195900., 2212014., 2228128., 3392850., 3419052.,
      3445254., 3471456., 3594610., 3622060., 3649510., 3676960., 3176116.,
      3200888., 3225660., 3250432., 1627468., 1641992., 1656516., 1671040.,
      1221638., 1231620., 1241602., 1251584., 1821886., 1838100., 1854314.,
      1870528., 1864606., 1881364., 1898122., 1914880., 1583724., 1598216.,
      1612708., 1627200., 806804.,  814968.,  823132.,  831296.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x18x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2991847., 3016686., 3041525., 3066364., 3112855., 3138606., 3164357.,
      3190108., 4086087., 4119662., 4153237., 4186812., 4045303., 4077742.,
      4110181., 4142620., 4256919., 4292654., 4328389., 4364124., 4086087.,
      4119662., 4153237., 4186812., 3442423., 3470510., 3498597., 3526684.,
      3548071., 3576046., 3604021., 3631996., 3347527., 3375214., 3402901.,
      3430588., 3442423., 3470510., 3498597., 3526684., 4279975., 4314350.,
      4348725., 4383100., 4205399., 4239662., 4273925., 4308188.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x18x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3083590., 4924782., 5273486., 5145332., 3111724., 5326174., 8267046.,
      7738054., 6590404., 3411164., 4898206., 7219814., 6952966., 7013188.,
      4266332., 4660524., 7406972., 7562556., 6672680., 3627032., 3131284.,
      4873796., 4998788., 4341592., 2212712., 3442150., 5273486., 5687726.,
      5214132., 3062892., 5627262., 7738054., 7219814., 6288772., 3843356.,
      4360126., 6952966., 7763878., 7548164., 4534684., 5059564., 7562556.,
      7193852., 6363048., 3746200., 3015380., 4998788., 4753604., 3857624.,
      2035176., 3551366., 5687726., 5583310., 4996212., 2644396., 4898206.,
      7219814., 6952966., 7013188., 4266332., 4845534., 7763878., 8064838.,
      7238340., 3988956., 5016236., 7193852., 6949564., 6021672., 3192600.,
      3353620., 4753604., 4223236., 3569240., 2069608.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x18x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8267046., 7738054., 7219814., 6952966., 7738054., 7219814.,
      6952966., 7763878., 7219814., 6952966., 7763878., 8064838.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x18x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3234834., 3258508., 4846058., 4884700., 4805354., 4844828., 4439612.,
      4475880., 2552036., 2573912., 4928042., 4966588., 7417122., 7479372.,
      7261730., 7322508., 6888588., 6943112., 3802132., 3833272., 4957226.,
      4995388., 7388962., 7449292., 7495714., 7554572., 7634060., 7690376.,
      4527124., 4560568., 5061148., 5099096., 7901548., 7962360., 7984492.,
      8044152., 7034888., 7088208., 3787704., 3817520., 3623044., 3647272.,
      5089460., 5127304., 4816052., 4853000., 4167864., 4201648., 1979784.,
      1999568., 3474706., 3500492., 4805354., 4844828., 4895722., 4936028.,
      4429372., 4466024., 2584804., 2607320., 5184298., 5224700., 7261730.,
      7322508., 7388962., 7449292., 7023756., 7077128., 4172820., 4206136.,
      4848938., 4885884., 7495714., 7554572., 8180002., 8242508., 7867532.,
      7924744., 4570132., 4605752., 5367324., 5405656., 7984492., 8044152.,
      7543148., 7601656., 6794248., 6845776., 4155320., 4186928., 3064964.,
      3087784., 4816052., 4853000., 4587700., 4624776., 3773624., 3807152.,
      1853832., 1873872., 3218962., 3243788., 4895722., 4936028., 4736234.,
      4776348., 4369980., 4407016., 2404580., 2425688., 4957226., 4995388.,
      7388962., 7449292., 7495714., 7554572., 7634060., 7690376., 4527124.,
      4560568., 5211690., 5250492., 8180002., 8242508., 8372770., 8434828.,
      7462028., 7518088., 4039700., 4071352., 5313052., 5351768., 7543148.,
      7601656., 7351660., 7407992., 6750216., 6802000., 3703736., 3735088.,
      3412100., 3436584., 4587700., 4624776., 4052148., 4088328., 3248312.,
      3279536., 1629576., 1647824.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x18x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7417122., 7479372., 7261730., 7322508., 7388962., 7449292.,
      7495714., 7554572., 7261730., 7322508., 7388962., 7449292.,
      7495714., 7554572., 8180002., 8242508., 7388962., 7449292.,
      7495714., 7554572., 8180002., 8242508., 8372770., 8434828.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, SAME3x18x18x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2736042., 2759716., 2783390., 2807064., 4596450., 4635092., 4673734.,
      4712376., 4891042., 4930516., 4969990., 5009464., 4645580., 4681848.,
      4718116., 4754384., 2493012., 2514888., 2536764., 2558640., 4929986.,
      4968532., 5007078., 5045624., 7879962., 7942212., 8004462., 8066712.,
      7423194., 7483972., 7544750., 7605528., 7152156., 7206680., 7261204.,
      7315728., 3942020., 3973160., 4004300., 4035440., 4923202., 4961364.,
      4999526., 5037688., 7792794., 7853124., 7913454., 7973784., 7598170.,
      7657028., 7715886., 7774744., 7428892., 7485208., 7541524., 7597840.,
      4472196., 4505640., 4539084., 4572528., 5022204., 5060152., 5098100.,
      5136048., 7865676., 7926488., 7987300., 8048112., 7770572., 7830232.,
      7889892., 7949552., 6663624., 6716944., 6770264., 6823584., 3982072.,
      4011888., 4041704., 4071520., 2962020., 2986248., 3010476., 3034704.,
      4664724., 4702568., 4740412., 4778256., 4643092., 4680040., 4716988.,
      4753936., 4067704., 4101488., 4135272., 4169056., 2467784., 2487568.,
      2507352., 2527136., 2984298., 3010084., 3035870., 3061656., 4891042.,
      4930516., 4969990., 5009464., 5185634., 5225940., 5266246., 5306552.,
      4526412., 4563064., 4599716., 4636368., 2738132., 2760648., 2783164.,
      2805680., 5276802., 5317204., 5357606., 5398008., 7423194., 7483972.,
      7544750., 7605528., 7792794., 7853124., 7913454., 7973784., 7079580.,
      7132952., 7186324., 7239696., 4222468., 4255784., 4289100., 4322416.,
      5068290., 5105236., 5142182., 5179128., 7598170., 7657028., 7715886.,
      7774744., 8029210., 8091716., 8154222., 8216728., 7550876., 7608088.,
      7665300., 7722512., 4621572., 4657192., 4692812., 4728432., 5060732.,
      5099064., 5137396., 5175728., 7770572., 7830232., 7889892., 7949552.,
      7151180., 7209688., 7268196., 7326704., 6495432., 6546960., 6598488.,
      6650016., 4322296., 4353904., 4385512., 4417120., 2502628., 2525448.,
      2548268., 2571088., 4643092., 4680040., 4716988., 4753936., 4448404.,
      4485480., 4522556., 4559632., 3836536., 3870064., 3903592., 3937120.,
      2494152., 2514192., 2534232., 2554272., 3030826., 3055652., 3080478.,
      3105304., 5185634., 5225940., 5266246., 5306552., 4981538., 5021652.,
      5061766., 5101880., 4833228., 4870264., 4907300., 4944336., 2559316.,
      2580424., 2601532., 2622640., 4923202., 4961364., 4999526., 5037688.,
      7792794., 7853124., 7913454., 7973784., 7598170., 7657028., 7715886.,
      7774744., 7428892., 7485208., 7541524., 7597840., 4472196., 4505640.,
      4539084., 4572528., 5103810., 5142612., 5181414., 5220216., 8029210.,
      8091716., 8154222., 8216728., 8005594., 8067652., 8129710., 8191768.,
      6921244., 6977304., 7033364., 7089424., 4154500., 4186152., 4217804.,
      4249456., 4902652., 4941368., 4980084., 5018800., 7151180., 7209688.,
      7268196., 7326704., 7032524., 7088856., 7145188., 7201520., 6456264.,
      6508048., 6559832., 6611616., 4074744., 4106096., 4137448., 4168800.,
      2802020., 2826504., 2850988., 2875472., 4448404., 4485480., 4522556.,
      4559632., 4164628., 4200808., 4236988., 4273168., 3869560., 3900784.,
      3932008., 3963232., 2063816., 2082064., 2100312., 2118560.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow11Stride4, VALID3x18x18x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7879962., 7942212., 8004462., 8066712., 7423194., 7483972., 7544750.,
      7605528., 7792794., 7853124., 7913454., 7973784., 7598170., 7657028.,
      7715886., 7774744., 7423194., 7483972., 7544750., 7605528., 7792794.,
      7853124., 7913454., 7973784., 7598170., 7657028., 7715886., 7774744.,
      8029210., 8091716., 8154222., 8216728., 7792794., 7853124., 7913454.,
      7973784., 7598170., 7657028., 7715886., 7774744., 8029210., 8091716.,
      8154222., 8216728., 8005594., 8067652., 8129710., 8191768.};
  const std::array<int, 4> in_shape = {{3, 18, 18, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 256.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}